core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/internal/core/SourceModuleInfoCache.java

/*******************************************************************************
 * Copyright (c) 2005, 2017 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.core;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.dltk.annotations.Internal;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ISourceModuleInfoCache;

/**
 * Used to cache some source module information. All information related to
 * source module are removed, then source module are changed.
 */
public class SourceModuleInfoCache implements ISourceModuleInfoCache,
		IResourceChangeListener, IResourceDeltaVisitor {
	@Internal
	final int capacity = ModelCache.DEFAULT_ROOT_SIZE * 50;

	private final ReferenceQueue<ISourceModuleInfo> queue = new ReferenceQueue<>();

	@SuppressWarnings("serial")
	private final Map<ISourceModule, CacheReference> map = new LinkedHashMap<ISourceModule, CacheReference>(
			16, 0.9f, true) {
		@Override
		protected boolean removeEldestEntry(
				Map.Entry<ISourceModule, CacheReference> eldest) {
			return size() > capacity;
		}
	};

	private static class CacheReference
			extends SoftReference<ISourceModuleInfo> {
		final long modificationStamp;
		final ISourceModule module;

		public CacheReference(ISourceModule module, ISourceModuleInfo referent,
				ReferenceQueue<? super ISourceModuleInfo> q) {
			super(referent, q);
			this.module = module;
			this.modificationStamp = getModificationStamp(module);
		}

		private static long getModificationStamp(ISourceModule module) {
			final IResource resource = module.getResource();
			return resource != null ? resource.getModificationStamp()
					: IResource.NULL_STAMP;
		}

		public boolean isValid(ISourceModule module) {
			final IResource resource = module.getResource();
			return resource == null
					|| resource.getModificationStamp() == modificationStamp;
		}

	}

	public void start() {
		DLTKCore.addPreProcessingResourceChangedListener(this,
				IResourceChangeEvent.POST_CHANGE);
	}

	public void stop() {
		DLTKCore.removePreProcessingResourceChangedListener(this);
	}

	private void expungeStaleEntries() {
		for (CacheReference r; (r = (CacheReference) queue.poll()) != null;) {
			if (DEBUG) {
				System.out.println(
						"[Cache] expunge " + r.module.getElementName());
			}
			map.remove(r.module);
		}
	}

	@Override
	public synchronized ISourceModuleInfo get(ISourceModule module) {
		expungeStaleEntries();
		final CacheReference ref = map.get(module);
		if (ref != null) {
			final ISourceModuleInfo info = ref.get();
			if (info != null && ref.isValid(module)) {
				return info;
			}
		}
		final ISourceModuleInfo info = new SourceModuleInfo();
		map.put(module, new CacheReference(module, info, queue));
		return info;
	}

	@Override
	public synchronized void resourceChanged(IResourceChangeEvent event) {
		expungeStaleEntries();
		final IResourceDelta delta = event.getDelta();
		try {
			delta.accept(this);
		} catch (CoreException e) {
			DLTKCore.error(e);
		}
	}

	@Override
	public boolean visit(IResourceDelta delta) throws CoreException {
		final int kind = delta.getKind();
		if (kind == IResourceDelta.ADDED) {
			return false;
		}
		final IResource resource = delta.getResource();
		switch (kind) {
		case IResourceDelta.CHANGED:
			switch (resource.getType()) {
			case IResource.PROJECT:
				if ((delta.getFlags() & IResourceDelta.OPEN) != 0) {
					final IProject project = (IProject) resource;
					if (!project.isOpen()) {
						removeByProject(project);
						return false;
					}
				}
				return true;
			case IResource.FOLDER:
				return true;
			case IResource.FILE:
				if ((delta.getFlags() & IResourceDelta.CONTENT) != 0) {
					remove((IFile) resource);
				}
				break;
			}
			break;
		case IResourceDelta.REMOVED:
			switch (resource.getType()) {
			case IResource.PROJECT:
				removeByProject((IProject) resource);
				return false;
			case IResource.FOLDER:
				return true;
			case IResource.FILE:
				remove((IFile) resource);
				return false;
			}
		}
		return true;
	}

	@Internal
	static class SourceModuleInfo implements ISourceModuleInfo {
		private Map<Object, Object> map;

		@Override
		public synchronized Object get(String key) {
			if (map == null) {
				return null;
			}
			return map.get(key);
		}

		@Override
		public synchronized void put(String key, Object value) {
			if (map == null) {
				map = new HashMap<>();
			}
			map.put(key, value);
		}

		@Override
		public synchronized void remove(String key) {
			if (map != null) {
				map.remove(key);
			}
		}

		@Override
		public synchronized boolean isEmpty() {
			return this.map == null || this.map.isEmpty();
		}
	}

	/**
	 * Not synchronized here, as it's called only from
	 * {@link #resourceChanged(IResourceChangeEvent)} which is already
	 * synchronized.
	 */
	private void removeByProject(IProject project) {
		for (Iterator<ISourceModule> i = map.keySet().iterator(); i
				.hasNext();) {
			final ISourceModule module = i.next();
			if (project.equals(module.getScriptProject().getProject())) {
				i.remove();
			}
		}
	}

	public void remove(IFile file) {
		remove(DLTKCore.createSourceModuleFrom(file));
	}

	@Override
	public synchronized void remove(ISourceModule module) {
		if (DEBUG) {
			System.out.println("[Cache] remove " + module.getElementName()); //$NON-NLS-1$
		}
		map.remove(module);
	}

	private static final boolean DEBUG = false;

	@Override
	public synchronized void clear() {
		// clear out reference queue.
		while (queue.poll() != null)
			;
		map.clear();
	}

	@Override
	public synchronized int size() {
		return map.size();
	}

	@Override
	public int capacity() {
		return capacity;
	}

}