Init the licenses cache

@param licenses
555452
private void init(final List<DbLicense> licenses) {
        licensesRegexp.clear();

        for (final DbLicense license : licenses) {
            if (license.getRegexp() == null ||
                    license.getRegexp().isEmpty()) {
                licensesRegexp.put(license.getName(), license);
            } else {
                licensesRegexp.put(license.getRegexp(), license);
            }
        }
    }
1216619
public void setAddLicenseSpecifications(java.util.Collection<LicenseSpecification> addLicenseSpecifications) {
        if (addLicenseSpecifications == null) {
            this.addLicenseSpecifications = null;
            return;
        }

        this.addLicenseSpecifications = new java.util.ArrayList<LicenseSpecification>(addLicenseSpecifications);
    }
1366813
public static void initialize()
    {
        if (AppConfigHandler.get().isQueryCacheDeactivated()) {
            QueryCache.NOOP = new NoOpQueryCache();
        } else {
            if (InfinispanCache.get().exists(QueryCache.INDEXCACHE)) {
                InfinispanCache.get().<String, QueryKey>getCache(QueryCache.INDEXCACHE).clear();
            } else {
                final Cache<String, QueryKey> cache = InfinispanCache.get().<String, QueryKey>getCache(
                                QueryCache.INDEXCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
            }
            if (InfinispanCache.get().exists(QueryCache.SQLCACHE)) {
                InfinispanCache.get().<QueryKey, Object>getCache(QueryCache.SQLCACHE).clear();
            } else {
                final Cache<QueryKey, Object> cache = InfinispanCache.get().<QueryKey, Object>getCache(
                                QueryCache.SQLCACHE);
                cache.addListener(new CacheLogListener(QueryCache.LOG));
                cache.addListener(new SqlCacheListener());
            }
        }
    }
425993
protected void initCaches(int cacheSize) {

        m_offlineJsps = CmsMemoryMonitor.createLRUCacheMap(cacheSize);
        m_onlineJsps = CmsMemoryMonitor.createLRUCacheMap(cacheSize);
    }
674965
public static function init() :void {

		// marker
		Profiler::setMarker('Bundles.init', 'framework');

		// if cache is enabled and in prod load the cache, else parse bundles
		Config::isProd() && Cache::has('Includes') ? self::loadCachedDependencies() : self::loadDependencies();
		
		// now that we have the list of config files, pass them to the config class
		Config::includeBundlesConfigs(self::$_configs);

		// now that we have the list of route files, pass them to the router class
		Router::includeBundlesRoutes(self::$_routes);

		// marker
		Profiler::releaseMarker('Bundles.init');

	}
492751
@Override
    public void init() throws InitializationException {
        engine = Engine.createCachingEngine();
        JMTEDateRendrer dateRendrer = new JMTEDateRendrer();
        dateRendrer.setDateFormat(dateFormat);
        engine.registerRenderer(Date.class, dateRendrer);
    }
1317429
public void initAllLoadedPlugins() throws PluginException {
		LOGGER.debug("Initializig all loaded plugins");
		for (Class<? extends Plugin> pluginClass : implementations.keySet()) {
			Set<PluginContext> set = implementations.get(pluginClass);
			for (PluginContext pluginContext : set) {
				try {
					pluginContext.initialize(pluginContext.getSystemSettings());
				} catch (Throwable e) {
					LOGGER.error("", e);
					pluginContext.setEnabled(false, false);
				}
			}
		}
	}
694902
private synchronized void startCache()
    {
        for (PDatabase pDatabase : m_htDBList.values())
        {
            for (PTable pTable : pDatabase.getTableList().values())
            {
                this.addTableToCache(pTable);
            }
        }
    }
447667
public void init(ClassLoader loader, ContextSource[] contextSources, boolean profilingEnabled)
        throws Exception {

        init(loader, contextSources, null, profilingEnabled);
    }
629326
public void setLicenseSpecifications(java.util.Collection<LicenseSpecification> licenseSpecifications) {
        if (licenseSpecifications == null) {
            this.licenseSpecifications = null;
            return;
        }

        this.licenseSpecifications = new java.util.ArrayList<LicenseSpecification>(licenseSpecifications);
    }
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));
        }
    }
1239486
public static void initialize()
    {
        if (InfinispanCache.get().exists(Company.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Company>getCache(Company.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Company>getCache(Company.UUIDCACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
        if (InfinispanCache.get().exists(Company.IDCACHE)) {
            InfinispanCache.get().<Long, Company>getCache(Company.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Company>getCache(Company.IDCACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
        if (InfinispanCache.get().exists(Company.NAMECACHE)) {
            InfinispanCache.get().<String, Company>getCache(Company.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Company>getCache(Company.NAMECACHE)
                            .addListener(new CacheLogListener(Company.LOG));
        }
    }
189417
protected void initCacheObject() {

        CmsImageCacheHelper helper = new CmsImageCacheHelper(getCms(), false, false, true);
        setKeys("" + helper.getFilesCount());
        setVariations("" + helper.getVariationsCount());
        setCurSize(CmsFileUtil.formatFilesize(helper.getVariationsSize(), getLocale()));
    }
897581
private void registerExtensions() {
    Iterator<Cache2kExtensionProvider> it =
      ServiceLoader.load(Cache2kExtensionProvider.class, CacheManager.class.getClassLoader()).iterator();
    while (it.hasNext()) {
      try {
        it.next().registerCache2kExtension();
      } catch (ServiceConfigurationError ex) {
        Log.getLog(CacheManager.class.getName()).debug("Error loading cache2k extension", ex);
      }
    }
  }
136257
protected void initDeployers() {
    if (this.deployers == null) {
      this.deployers = new ArrayList<Deployer>();
      if (customPreDeployers != null) {
        this.deployers.addAll(customPreDeployers);
      }
      this.deployers.addAll(getDefaultDeployers());
      if (customPostDeployers != null) {
        this.deployers.addAll(customPostDeployers);
      }
    }
    if (deploymentCache == null) {
      List<Deployer> deployers = new ArrayList<Deployer>();
      if (customPreDeployers != null) {
        deployers.addAll(customPreDeployers);
      }
      deployers.addAll(getDefaultDeployers());
      if (customPostDeployers != null) {
        deployers.addAll(customPostDeployers);
      }

      initCacheFactory();
      deploymentCache = new DeploymentCache(cacheFactory, cacheCapacity);
      deploymentCache.setDeployers(deployers);
    }
  }
692774
public static void initialize(final Class<?> _class)
        throws CacheReloadException
    {
        if (InfinispanCache.get().exists(Type.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE).addListener(new CacheLogListener(Type.LOG));
        }
        if (InfinispanCache.get().exists(Type.IDCACHE)) {
            InfinispanCache.get().<Long, Type>getCache(Type.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Type>getCache(Type.IDCACHE).addListener(new CacheLogListener(Type.LOG));
        }
        if (InfinispanCache.get().exists(Type.NAMECACHE)) {
            InfinispanCache.get().<String, Type>getCache(Type.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Type>getCache(Type.NAMECACHE).addListener(new CacheLogListener(Type.LOG));
        }
        if (InfinispanCache.get().exists(EnumType.CACHE)) {
            InfinispanCache.get().getCache(EnumType.CACHE).clear();
        }
        QueryCache.initialize();
    }
815307
public static void initialize()
    {
        if (InfinispanCache.get().exists(AccessSet.UUIDCACHE)) {
            InfinispanCache.get().<UUID, AccessSet>getCache(AccessSet.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, AccessSet>getCache(AccessSet.UUIDCACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
        if (InfinispanCache.get().exists(AccessSet.IDCACHE)) {
            InfinispanCache.get().<Long, AccessSet>getCache(AccessSet.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, AccessSet>getCache(AccessSet.IDCACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
        if (InfinispanCache.get().exists(AccessSet.NAMECACHE)) {
            InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, AccessSet>getCache(AccessSet.NAMECACHE)
                            .addListener(new CacheLogListener(AccessSet.LOG));
        }
    }