001: package com.completex.objective.components.ocache.impl;
002:
003: import com.completex.objective.components.ocache.*;
004:
005: import java.util.HashMap;
006: import java.util.Iterator;
007:
008: /**
009: * @author Gennady Krizhevsky
010: */
011: public class LinkedCacheFactoryImpl implements OdalCacheFactory {
012:
013: private ValueTransformer valueTransformer;
014: private HashMap caches = new HashMap();
015: private boolean initialized;
016:
017: public void registerCache(OdalCache cache) {
018: registerCache(cache, null);
019: }
020:
021: /**
022: * Creates linked cache out of regular ones.
023: * The first cache element is the master one. Its name will be returned by getName() method.
024: *
025: * @param cache
026: * @param keyFactory
027: * @throws OdalRuntimeCacheException if keyFactory is null or the cache is initialized (been used)
028: */
029: public synchronized void registerCache(OdalCache cache,
030: OdalKeyFactory keyFactory) {
031: registerCache(cache, keyFactory, null);
032: }
033:
034: public void registerCache(OdalCache cache,
035: OdalKeyFactory keyFactory, OdalCacheConfig cacheConfig) {
036: invalidateInitialized();
037: if (keyFactory == null) {
038: throw new OdalRuntimeCacheException(
039: "OdalKeyFactory is null for LinkedCacheFactory");
040: }
041:
042: cacheConfig = OdalCacheConfig.merge(
043: DefaultCacheFactoryImpl.DEFAULT_CONFIG, cacheConfig);
044: if (!cacheConfig.isDisabled()) {
045: if (!caches.containsKey(cache.getName())) {
046: OdalCache element = toOdalKeyedCache(cache, keyFactory,
047: cacheConfig.isMarkCacheCollectionElements());
048: caches.put(element.getName(), element);
049: } else {
050: throw new OdalRuntimeCacheException(
051: "Cache with name ["
052: + cache.getName()
053: + "] already existes in this LinkedCacheFactory");
054: }
055: }
056: }
057:
058: protected OdalCache toOdalKeyedCache(OdalCache cache,
059: OdalKeyFactory keyFactory,
060: boolean markCacheCollectionElements) {
061: if (!(cache instanceof SafeLinkedCacheImpl)) {
062: if (!(cache instanceof LinkedCacheImpl)) {
063: cache = new LinkedCacheImpl(cache, keyFactory,
064: valueTransformer, markCacheCollectionElements);
065: }
066: cache = new SafeLinkedCacheImpl(((LinkedCacheImpl) cache));
067: }
068: return cache;
069: }
070:
071: /**
072: * Unregisters cache
073: *
074: * @param name
075: * @throws OdalRuntimeCacheException if the cache is initialized (been used)
076: */
077: public synchronized void unregisterCache(String name) {
078: invalidateInitialized();
079: caches.remove(name);
080: }
081:
082: protected void invalidateInitialized() {
083: if (initialized) {
084: throw new OdalRuntimeCacheException(
085: "LinkedCacheFactory is initialized and therefore immutable");
086: }
087: }
088:
089: public synchronized OdalKeyedCache getCache(String name) {
090: if (!initialized) {
091: initialize();
092: }
093: OdalKeyedCache cache = (OdalKeyedCache) caches.get(name);
094: return cache == null ? OdalLinkedCache.NULL_ODAL_LINKED_CACHE
095: : cache;
096: }
097:
098: /**
099: * Links all the registered caches
100: */
101: protected void initialize() {
102: for (Iterator it = caches.keySet().iterator(); it.hasNext();) {
103: String key = (String) it.next();
104: OdalLinkedCache elementA = (OdalLinkedCache) caches
105: .get(key);
106: for (Iterator it2 = caches.keySet().iterator(); it2
107: .hasNext();) {
108: String key2 = (String) it2.next();
109: OdalLinkedCache elementB = (OdalLinkedCache) caches
110: .get(key2);
111: if (elementA != elementB) {
112: elementA.addListener(elementB);
113: }
114: }
115: }
116: initialized = true;
117: }
118:
119: public ValueTransformer getValueTransformer() {
120: return valueTransformer;
121: }
122:
123: public void setValueTransformer(ValueTransformer valueTransformer) {
124: this.valueTransformer = valueTransformer;
125: }
126:
127: }
|