org.unlaxer.util.cache.BoundCache Maven / Gradle / Ivy

Go to download
package org.unlaxer.util.cache;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

public abstract class BoundCache{
	
	private static Collection caches =  new ArrayList();
	
	private static Map> cachesByNamme = new HashMap<>();
	
	NameAndTags nameAndTags;
	
	public BoundCache(NameAndTags nameAndTags) {
		super();
		this.nameAndTags = nameAndTags;
		add(nameAndTags , this);
		
	}
	
	public abstract void clear();

	public static void add(NameAndTags nameAndTags, BoundCache boundCache) {
		caches.add(boundCache);

		nameAndTags.tags.get().stream().map(Tag::toString).forEach(nameAsString->{
			cachesByNamme
			.computeIfAbsent(nameAsString, x-> new ArrayList<>())
			.add(boundCache);
		});
	}

	public static synchronized int clearAllCaches(){
		int size = caches.size();
		caches.stream().parallel().forEach(BoundCache::clear);
		return size;
	}
	
	public static synchronized int clearCaches(Tag name){
		
		AtomicInteger counts = new AtomicInteger();
		String nameAString = name.toString();
		Set collectByTag = cachesByNamme.entrySet().stream()
			.filter(entry->{
				return entry.getKey().equals(nameAString);
			})
			.map(Entry::getValue)
			.flatMap(Collection::stream)
			.distinct()
			.peek(x->counts.incrementAndGet())
			.collect(Collectors.toSet());
//			.forEach(BoundCache::clear);
		
		Set collectByName = caches.stream()
			.filter(cache->cache.toString().equals(nameAString))
			.distinct()
			.peek(x->counts.incrementAndGet())
			.collect(Collectors.toSet());
		
		collectByName.addAll(collectByTag);
		
		collectByName.stream()
			.forEach(BoundCache::clear);
		
		return counts.get();
	}
	
	public static Map> getCachesByNamme(){
		return cachesByNamme;
	}

	
	public NameAndTags nameAndTags() {
		return nameAndTags;
	}
	
	public enum ReturningStrategy{
		returnOptionalWhenNotPrepared,
		blockingWhenNotPrepared,
	}
	
	public enum updatingStrategy{
		updateWithDoubleBuffer,
		updateWithSinglebuffer,
	}

	@Override
	public String toString() {
		return nameAndTags.name;
	}
}