IResourceDescription.Event.Listener

IResourceDescription.Event.Source

	@Inject
	var ResourceDescriptionsProvider rdp

	@Inject 
	IContainer.Manager cm

	/** Returns all eObject descriptions of a provided type that are visible from a provided object o. */
	private def searchIndexByName(EObject o, EClass type, QualifiedName fqn) {
		val tmp = o.getVisibleContainers.map [ c |
			c.getExportedObjects(type, fqn, false)
		]
		return tmp.flatten
	}


	/** Returns all containers that are visible from a provided object o. A container is, e.g., an Eclipse project or a class path item. */
	private def getVisibleContainers(EObject o) {
		if (o?.eResource === null)
			return emptyList
		val index = rdp.getResourceDescriptions(o.eResource)
		val rd = index.getResourceDescription(o.eResource.URI)
		if (rd === null) {
			// do something else
			return emptyList
		}
		cm.getVisibleContainers(rd, index)
	}

rdp.getResourceDescriptions(Resource)

DefaultResourceDescriptionManager.getImportedNames

IResourceDescriptionsProvider.getResourceDescription(Resource)

EObjectDescriptionLookUp

getExportedObjects()

StateBasedContainer

isEmpty()

getVisibleContainers

class MyStateBasedContainerManager extends StateBasedContainerManager {
	
	
	override protected getVisibleContainers(List<String> handles, IResourceDescriptions resourceDescriptions) {
		if (handles.isEmpty())
			return Collections.emptyList();
		val List<IContainer> result = Lists.newArrayListWithExpectedSize(handles.size());
		for(String handle: handles) {
			val IContainer container = createContainer(handle, resourceDescriptions);
//			if (!container.isEmpty() || result.isEmpty())
//			println("Not calling is Empty()...")
			result.add(container);
		}
		return result;
	}
	
}

/** 
 * The default implementation of an IndexBackedCache. 
 */
@Singleton
class IndexBackedCacheImpl implements IndexBackedCache {
	/** Holds a list of all buckets that need to be cleared when an item of a certain type is added to the index. */
	val Multimap<EClass, IndexBackedCacheBucket> refreshMap = LinkedListMultimap.create;
	/** Maps the bucket that holds the cached values to its type. */
	val Map<EClass, IndexBackedCacheBucket> caches = newHashMap
	
	@Inject
	Provider<IndexBackedCacheBucket> cacheProv
	
	
	override void onNewElement(EClass typeOfNewElement) {
		val cs = getAffectedBuckets(typeOfNewElement)
		
		for (c : cs) {
			c.clear
		}
	}
	
	override <T> T get(EClass type, Object key, Provider<T> provider) {
		var cache = caches.get(type)
		if (cache === null) {
			cache = create(type);
		}
		
		cache.get(key, provider)
	}
	
	/** Creates a new Cache bucket of the provided type. */
	private def create(EClass type) {
		val rslt = cacheProv.get
		rslt.type = type
		
		caches.put(type, rslt)
		refreshMap.clear
		
		return rslt
	}
	
	/** Returns the cache buckets that should be refreshed when a new item of the provided type is added
	 * to the index. The returned list thus returns all cache buckets for any super types of the provided type. */
	private def getAffectedBuckets(EClass type) {
		val rslt = refreshMap.get(type)
		if (!rslt.nullOrEmpty)
			return rslt
			
		rebuildRefreshMapEntry(type)
		
		val r = refreshMap.get(type)
//		if (!r.nullOrEmpty)
//			println('''«type.name» -> Refresh «r.map[it.type.name].join(", ")»''')
		
		return r
	}
	
	/** Rebuilds the entry in the refresh map for the provided type.*/
	private def rebuildRefreshMapEntry(EClass type) {
		for (e : caches.entrySet) {
			val t = e.key
			val c = e.value
			
			if (t.isSuperTypeOf(type)) {
				refreshMap.put(type, c)
			}
		}
	}
	
	/** An inner bucket, which holds the actual cached values. */
	static class IndexBackedCacheBucket {
		val Map<Object, Object> items = newHashMap;
		
		@Accessors(#[PUBLIC_GETTER])
		var EClass type;
		
		protected new() {
			// do nothing
		}
	
		def <T> T get(Object key, Provider<T> provider) {
			var rslt = items.get(key)
			if (rslt !== null || items.containsKey(key)) {
				// cache hit
				return rslt as T
			} else {
				// cache miss
				val tmp = provider.get
				items.put(key, tmp)
				return tmp
			}
		}
		
		def clear() {
//			println('''Flushing Bucket «type.name»''')
			items.clear
		}
	}
}