Initializes the cache object.<p>
189417
protected void initCacheObject() {

        CmsImageCacheHelper helper = new CmsImageCacheHelper(getCms(), false, false, true);
        setKeys("" + helper.getFilesCount());
        setVariations("" + helper.getVariationsCount());
        setCurSize(CmsFileUtil.formatFilesize(helper.getVariationsSize(), getLocale()));
    }
10606
protected void initialize() {

        if (m_folderList != null) {
            // ensure folders are sorted starting with parent folders
            Collections.sort(m_folderList, I_CmsResource.COMPARE_ROOT_PATH);
        }

        if (m_fileList != null) {
            // ensure files are sorted starting with files in parent folders
            Collections.sort(m_fileList, I_CmsResource.COMPARE_ROOT_PATH);
        }

        if (m_deletedFolderList != null) {
            // ensure deleted folders are sorted starting with child folders
            Collections.sort(m_deletedFolderList, I_CmsResource.COMPARE_ROOT_PATH);
            Collections.reverse(m_deletedFolderList);
        }
    }
340451
@Inject
   protected void init(EmbeddedCacheManager cacheManager, InternalCacheRegistry internalCacheRegistry) {
      this.cacheManager = cacheManager;
      internalCacheRegistry.registerInternalCache(PROTOBUF_METADATA_CACHE_NAME,
            getProtobufMetadataCacheConfig().build(),
            EnumSet.of(Flag.USER, Flag.PROTECTED, Flag.PERSISTENT));
   }
255391
public static void initialize()
    {
        if (InfinispanCache.get().exists(Field.IDCACHE)) {
            InfinispanCache.get().<Long, Field>getCache(Field.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Field>getCache(Field.IDCACHE);
            InfinispanCache.get().<Long, Field>getCache(Field.IDCACHE).addListener(new CacheLogListener(Field.LOG));
        }
    }
1297970
public function init()
    {
        parent::init();
        $this->sessionKey = $this->getSessionKey();
        $this->cache = Instance::ensure($this->cache, Cache::class);
    }
1374198
private void init() {
        cacheable = null;
        status = SC_OK;
        cachedResponse = cached.createCachedResponse();
        streamDelegate = new ServletResponseStreamDelegate(this) {
            protected OutputStream createOutputStream() throws IOException {
                // Test if this request is really cacheable, otherwise,
                // just write through to underlying response, and don't cache
                if (isCacheable()) {
                    return cachedResponse.getOutputStream();
                }
                else {
                    cachedResponse.setStatus(status);
                    cachedResponse.writeHeadersTo(CacheResponseWrapper.this.response);
                    return super.getOutputStream();
                }
            }
        };
    }
559304
public void init() {
		if (initDepth.get() == null) {
			initDepth.set(1);
		} else {
			initDepth.set(initDepth.get() + 1);
		}

		if (resourceCache.get() == null) {
			resourceCache.set(new HashMap<String, Object>());
		}

		if (cacheLocked.get() == null) {
			cacheLocked.set(Boolean.FALSE);
		}
	}
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));
        }
    }
730730
private void initStream() throws IOException {

        if (m_out == null) {
            if (!m_writeOnlyToBuffer) {
                // we can use the parents output stream
                if (m_cachingRequired || (m_controller.getResponseStackSize() > 1)) {
                    // we are allowed to cache our results (probably to construct a new cache entry)
                    m_out = new CmsFlexResponse.CmsServletOutputStream(m_res.getOutputStream());
                } else {
                    // we are not allowed to cache so we just use the parents output stream
                    m_out = (CmsFlexResponse.CmsServletOutputStream)m_res.getOutputStream();
                }
            } else {
                // construct a "buffer only" output stream
                m_out = new CmsFlexResponse.CmsServletOutputStream();
            }
        }
        if (m_writer == null) {
            // create a PrintWriter that uses the encoding required for the request context
            m_writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(m_out, m_encoding)), false);
        }
    }
368747
public function init() {

		parent::init();

		$cacheProperties = CacheProperties::getInstance();

		$this->cache = $cacheProperties->isCaching();

		// Init models
		$this->initModels();

		// Init Pagination
		$this->initPaging();
	}
1171225
public static void initialize(final Class<?> _class)
    {
        if (InfinispanCache.get().exists(SQLTable.UUIDCACHE)) {
            InfinispanCache.get().<UUID, SQLTable>getCache(SQLTable.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, SQLTable>getCache(SQLTable.UUIDCACHE)
                            .addListener(new CacheLogListener(SQLTable.LOG));
        }
        if (InfinispanCache.get().exists(SQLTable.IDCACHE)) {
            InfinispanCache.get().<Long, SQLTable>getCache(SQLTable.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, SQLTable>getCache(SQLTable.IDCACHE)
                            .addListener(new CacheLogListener(SQLTable.LOG));
        }
        if (InfinispanCache.get().exists(SQLTable.NAMECACHE)) {
            InfinispanCache.get().<String, SQLTable>getCache(SQLTable.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, SQLTable>getCache(SQLTable.NAMECACHE)
                            .addListener(new CacheLogListener(SQLTable.LOG));
        }
    }
662849
@Override
    public void init() {

        if (CmsImageLoader.isEnabled()) {
            try {
                //reads the optional parameters for the gallery from the XML configuration
                I_CmsResourceType type = OpenCms.getResourceManager().getResourceType(GALLERYTYPE_NAME);
                if (type instanceof CmsResourceTypeFolderExtended) {
                    m_galleryTypeParams = ((CmsResourceTypeFolderExtended)type).getFolderClassParams();
                } else {
                    m_galleryTypeParams = null;
                }
            } catch (CmsLoaderException e) {
                if (LOG.isErrorEnabled()) {
                    LOG.error(e.getLocalizedMessage(), e);
                }
            }
            m_defaultScaleParams = new CmsImageScaler(m_galleryTypeParams);
            if (!m_defaultScaleParams.isValid()) {
                // no valid parameters have been provided, use defaults
                m_defaultScaleParams.setType(0);
                m_defaultScaleParams.setPosition(0);
                m_defaultScaleParams.setWidth(120);
                m_defaultScaleParams.setHeight(90);
                m_defaultScaleParams.setColor(new Color(221, 221, 221));
            }
        } else {
            m_defaultScaleParams = null;
        }
    }
849094
private synchronized void initSystemCache() {
        List<StoreDefinition> value = storeMapper.readStoreList(new StringReader(SystemStoreConstants.SYSTEM_STORE_SCHEMA));
        metadataCache.put(SYSTEM_STORES_KEY, new Versioned<Object>(value));
    }
425993
protected void initCaches(int cacheSize) {

        m_offlineJsps = CmsMemoryMonitor.createLRUCacheMap(cacheSize);
        m_onlineJsps = CmsMemoryMonitor.createLRUCacheMap(cacheSize);
    }
463580
public void init(boolean useDirect, int outSize, int inSize, int cacheSize) {
        super.init(useDirect, outSize, inSize, cacheSize);
    }
433668
public static void initialize()
        throws CacheReloadException
    {
        if (InfinispanCache.get().exists(Store.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Store>getCache(Store.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Store>getCache(Store.UUIDCACHE).addListener(new CacheLogListener(Store.LOG));
        }
        if (InfinispanCache.get().exists(Store.IDCACHE)) {
            InfinispanCache.get().<Long, Store>getCache(Store.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Store>getCache(Store.IDCACHE).addListener(new CacheLogListener(Store.LOG));
        }
        if (InfinispanCache.get().exists(Store.NAMECACHE)) {
            InfinispanCache.get().<String, Store>getCache(Store.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Store>getCache(Store.NAMECACHE).addListener(new CacheLogListener(Store.LOG));
        }
    }
283474
public static void initialize()
    {
        if (InfinispanCache.get().exists(Person.IDCACHE)) {
            InfinispanCache.get().<Long, Person>getCache(Person.IDCACHE).clear();
        } else {
            InfinispanCache.get().<Long, Person>getCache(Person.IDCACHE).addListener(new CacheLogListener(Person.LOG));
        }
        if (InfinispanCache.get().exists(Person.NAMECACHE)) {
            InfinispanCache.get().<String, Person>getCache(Person.NAMECACHE).clear();
        } else {
            InfinispanCache.get().<String, Person>getCache(Person.NAMECACHE)
                            .addListener(new CacheLogListener(Person.LOG));
        }
        if (InfinispanCache.get().exists(Person.UUIDCACHE)) {
            InfinispanCache.get().<UUID, Person>getCache(Person.UUIDCACHE).clear();
        } else {
            InfinispanCache.get().<UUID, Person>getCache(Person.UUIDCACHE)
                            .addListener(new CacheLogListener(Person.LOG));
        }
    }