plugins/org.eclipse.wst.validation/vf2/org/eclipse/wst/validation/internal/DependencyIndex.java - webtools-common/webtools.common - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2008 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
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.wst.validation.internal;

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ISaveContext;
 import org.eclipse.core.resources.ISaveParticipant;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.wst.validation.DependentResource;
 import org.eclipse.wst.validation.IDependencyIndex;
 import org.eclipse.wst.validation.Validator;
 import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;

 public class DependencyIndex implements IDependencyIndex, ISaveParticipant {

 	/**
 	 * Keep track of which resources are depended on by other resources.
 	 * <p>
 	 * The reason we don't store IResources in this map is because the IResource may not
 	 * actually exist. (It may have been renamed or deleted before this index was restored)
 	 */
 	private Map<IPath, Map<IResource,Depends>>		_dependsMap;
 	private Map<IProject, List<Depends>>			_projectMap;
 	private boolean _dirty;

 	private static IResource[] EmptyResources = new IResource[0];

 	/** Version of the persistent index. */
 	private static final int CurrentVersion = 1;

 	public synchronized void add(String id, IResource dependent, IResource dependsOn) {
 		init();
 		IPath dependsOnPath = dependsOn.getFullPath();
 		add(id,dependent, dependsOnPath);
 	}

 	private void add(String id, IResource dependent, IPath dependsOn){
 		Map<IResource, Depends> depends = _dependsMap.get(dependsOn);
 		if (depends == null){
 			depends = new HashMap<IResource, Depends>(5);
 			_dependsMap.put(dependsOn, depends);
 		}

 		Depends d = depends.get(dependent);
 		if (d == null){
 			d = new Depends();
 			depends.put(dependent, d);
 		}
 		if (d.hasValidator(id))return;
 		else {
 			d.add(id);
 			_dirty = true;
 			List<Depends> list = _projectMap.get(dependent.getProject());
 			if (list == null){
 				list = new LinkedList<Depends>();
 				_projectMap.put(dependent.getProject(), list);
 			}
 			list.add(d);
 		}

 	}

 	/**
 	 * Restore the dependency index.
 	 * <p>
 	 * The format of the index is:
 	 * <pre>
 	 * Version number
 	 * Number of depends on entries
 	 *   depends on file name
 	 *   number of dependent entries
 	 *     dependent file name
 	 *     number of validators
 	 *       validator id
 	 * </pre>
 	 */
 	private void init() {
 		if (_dependsMap != null)return;

 		File f = getIndexLocation();
 		if (!f.exists()){
 			_dependsMap = new HashMap<IPath, Map<IResource, Depends>>(100);
 			_projectMap = new HashMap<IProject, List<Depends>>(50);
 		}
 		else {
 			DataInputStream in = null;
 			try {
 				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 				in = new DataInputStream(new FileInputStream(f));

 				int version = in.readInt();
 				if (version != CurrentVersion){
 					String msg = NLS.bind(ValMessages.ErrDependencyVersion, CurrentVersion);
 					throw new IllegalStateException(msg);
 				}
 				int numDependsOn = in.readInt();
 				_dependsMap = new HashMap<IPath, Map<IResource, Depends>>(numDependsOn+100);
 				_projectMap = new HashMap<IProject, List<Depends>>(50);
 				for (int i=0; i<numDependsOn; i++){
 					String v = in.readUTF();
 					IPath dependsOn = Path.fromPortableString(v);
 					int numDependents = in.readInt();
 					for (int j=0; j<numDependents; j++){
 						v = in.readUTF();
 						IResource dependent = root.findMember(v);
 						int numVal = in.readInt();
 						for (int k=0; k<numVal; k++){
 							String id = in.readUTF();
 							add(id, dependent, dependsOn);
 						}
 					}
 				}
 			}
 			catch (IOException e){
 				ValidationPlugin.getPlugin().handleException(e);
 			}
 			finally {
 				Misc.close(in);
 			}

 		}
 	}

 	public synchronized void clear(IProject project) {
 		init();
 		List<Depends> list = _projectMap.get(project);
 		if (list == null)return;

 		_dirty = true;
 		for (Depends d : list)d.delete();
 	}

 	public synchronized IResource[] get(String id, IResource dependsOn) {
 		init();
 		Map<IResource, Depends> map = _dependsMap.get(dependsOn.getFullPath());
 		if (map == null)return EmptyResources;

 		List<IResource> list = new LinkedList<IResource>();
 		for (Map.Entry<IResource, Depends> me : map.entrySet()){
 			if (me.getValue().hasValidator(id))list.add(me.getKey());
 		}
 		if (list.size() == 0)return EmptyResources;
 		IResource[] resources = new IResource[list.size()];
 		list.toArray(resources);
 		return resources;
 	}


 	public synchronized List<DependentResource> get(IResource dependsOn) {
 		init();
 		List<DependentResource> list = new LinkedList<DependentResource>();
 		Map<IResource, Depends> map = _dependsMap.get(dependsOn.getFullPath());
 		ValManager vm = ValManager.getDefault();
 		if (map != null){
 			for (Map.Entry<IResource, Depends> me : map.entrySet()){
 				for (String id : me.getValue().getValidatorsEnabled()){
 					IResource res = me.getKey();
 					Validator v = vm.getValidator(id, res.getProject());
 					if (v != null)list.add(new DependentResource(res, v));
 				}
 			}
 		}
 		return list;
 	}


 	public synchronized void set(String id, IResource dependent, IResource[] dependsOn) {
 		for (IResource d : dependsOn)add(id, dependent, d);
 	}

 	public boolean isDependedOn(IResource resource) {
 		init();
 		return _dependsMap.containsKey(resource.getFullPath());
 	}

 	public void doneSaving(ISaveContext context) {
 	}

 	public void prepareToSave(ISaveContext context) throws CoreException {
 	}

 	public void rollback(ISaveContext context) {
 	}

 	/**
 	 * Persist the dependency index.
 	 * <p>
 	 * The format of the index is:
 	 * <pre>
 	 * Version number
 	 * Number of depends on entries
 	 *   depends on file name
 	 *   number of dependent entries
 	 *     dependent file name
 	 *     number of validators
 	 *       validator id
 	 * </pre>
 	 */
 	public void saving(ISaveContext context) throws CoreException {
 		if (!_dirty)return;
 		_dirty = false;

 		DataOutputStream out = null;
 		try {
 			File f = getIndexLocation();
 			out = new DataOutputStream(new FileOutputStream(f));
 			out.writeInt(CurrentVersion);
 			out.writeInt(_dependsMap.size());
 			for (Map.Entry<IPath, Map<IResource, Depends>> me : _dependsMap.entrySet()){
 				IPath key = me.getKey();
 				out.writeUTF(key.toString());
 				Map<IResource, Depends> map = me.getValue();
 				out.writeInt(map.size());
 				for (Map.Entry<IResource, Depends> me2: map.entrySet()){
 					int vc = me2.getValue().validatorCount();
 					if (vc == 0)continue;

 					IResource key2 = me2.getKey();
 					out.writeUTF(key2.getFullPath().toString());
 					Map<String, Boolean> map3 = me2.getValue().getValidators();
 					out.writeInt(vc);
 					for (Map.Entry<String, Boolean> me3 : map3.entrySet()){
 						if (me3.getValue())out.writeUTF(me3.getKey());
 					}
 				}
 			}
 		}
 		catch (IOException e){
 			ValidationPlugin.getPlugin().handleException(e);
 		}
 		finally {
 			Misc.close(out);
 		}
 	}

 	private File getIndexLocation() {
 		IPath path = ValidationPlugin.getPlugin().getStateLocation().append("dep.index"); //$NON-NLS-1$
 		return path.toFile();
 	}

 private static class Depends {

 	/** The key is the validator dependencyId.*/
 	private Map<String, Boolean> 	_validators;

 	private Depends(){
 		_validators = new HashMap<String, Boolean>(5);
 	}

 	private Map<String, Boolean> getValidators() {
 		return _validators;
 	}

 	/**
 	 * Answer the validator id's that are still enabled.
 	 * @return
 	 */
 	private List<String> getValidatorsEnabled() {
 		List<String> list = new LinkedList<String>();
 		for (Map.Entry<String, Boolean> me : _validators.entrySet()){
 			if (me.getValue())list.add(me.getKey());
 		}
 		return list;
 	}

 	private void delete() {
 		_validators.clear();
 	}

 	private void add(String id) {
 		_validators.put(id, Boolean.TRUE);

 	}

 	private boolean hasValidator(String id) {
 		Boolean v = _validators.get(id);
 		if (v == null)return false;
 		return v.booleanValue();
 	}

 	/**
 	 * Answer the number of active dependencies.
 	 * @return
 	 */
 	private int validatorCount(){
 		int count = 0;
 		for (Boolean b : _validators.values()){
 			if (b)count++;
 		}
 		return count;
 	}

 }


 }
	/*******************************************************************************
	* Copyright (c) 2005, 2008 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
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.wst.validation.internal;

	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.util.HashMap;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.ISaveContext;
	import org.eclipse.core.resources.ISaveParticipant;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.osgi.util.NLS;
	import org.eclipse.wst.validation.DependentResource;
	import org.eclipse.wst.validation.IDependencyIndex;
	import org.eclipse.wst.validation.Validator;
	import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;

	public class DependencyIndex implements IDependencyIndex, ISaveParticipant {

	/**
	* Keep track of which resources are depended on by other resources.
	* <p>
	* The reason we don't store IResources in this map is because the IResource may not
	* actually exist. (It may have been renamed or deleted before this index was restored)
	*/
	private Map<IPath, Map<IResource,Depends>> _dependsMap;
	private Map<IProject, List<Depends>> _projectMap;
	private boolean _dirty;

	private static IResource[] EmptyResources = new IResource[0];

	/** Version of the persistent index. */
	private static final int CurrentVersion = 1;

	public synchronized void add(String id, IResource dependent, IResource dependsOn) {
	init();
	IPath dependsOnPath = dependsOn.getFullPath();
	add(id,dependent, dependsOnPath);
	}

	private void add(String id, IResource dependent, IPath dependsOn){
	Map<IResource, Depends> depends = _dependsMap.get(dependsOn);
	if (depends == null){
	depends = new HashMap<IResource, Depends>(5);
	_dependsMap.put(dependsOn, depends);
	}

	Depends d = depends.get(dependent);
	if (d == null){
	d = new Depends();
	depends.put(dependent, d);
	}
	if (d.hasValidator(id))return;
	else {
	d.add(id);
	_dirty = true;
	List<Depends> list = _projectMap.get(dependent.getProject());
	if (list == null){
	list = new LinkedList<Depends>();
	_projectMap.put(dependent.getProject(), list);
	}
	list.add(d);
	}

	}

	/**
	* Restore the dependency index.
	* <p>
	* The format of the index is:
	* <pre>
	* Version number
	* Number of depends on entries
	* depends on file name
	* number of dependent entries
	* dependent file name
	* number of validators
	* validator id
	* </pre>
	*/
	private void init() {
	if (_dependsMap != null)return;

	File f = getIndexLocation();
	if (!f.exists()){
	_dependsMap = new HashMap<IPath, Map<IResource, Depends>>(100);
	_projectMap = new HashMap<IProject, List<Depends>>(50);
	}
	else {
	DataInputStream in = null;
	try {
	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	in = new DataInputStream(new FileInputStream(f));

	int version = in.readInt();
	if (version != CurrentVersion){
	String msg = NLS.bind(ValMessages.ErrDependencyVersion, CurrentVersion);
	throw new IllegalStateException(msg);
	}
	int numDependsOn = in.readInt();
	_dependsMap = new HashMap<IPath, Map<IResource, Depends>>(numDependsOn+100);
	_projectMap = new HashMap<IProject, List<Depends>>(50);
	for (int i=0; i<numDependsOn; i++){
	String v = in.readUTF();
	IPath dependsOn = Path.fromPortableString(v);
	int numDependents = in.readInt();
	for (int j=0; j<numDependents; j++){
	v = in.readUTF();
	IResource dependent = root.findMember(v);
	int numVal = in.readInt();
	for (int k=0; k<numVal; k++){
	String id = in.readUTF();
	add(id, dependent, dependsOn);
	}
	}
	}
	}
	catch (IOException e){
	ValidationPlugin.getPlugin().handleException(e);
	}
	finally {
	Misc.close(in);
	}

	}
	}

	public synchronized void clear(IProject project) {
	init();
	List<Depends> list = _projectMap.get(project);
	if (list == null)return;

	_dirty = true;
	for (Depends d : list)d.delete();
	}

	public synchronized IResource[] get(String id, IResource dependsOn) {
	init();
	Map<IResource, Depends> map = _dependsMap.get(dependsOn.getFullPath());
	if (map == null)return EmptyResources;

	List<IResource> list = new LinkedList<IResource>();
	for (Map.Entry<IResource, Depends> me : map.entrySet()){
	if (me.getValue().hasValidator(id))list.add(me.getKey());
	}
	if (list.size() == 0)return EmptyResources;
	IResource[] resources = new IResource[list.size()];
	list.toArray(resources);
	return resources;
	}


	public synchronized List<DependentResource> get(IResource dependsOn) {
	init();
	List<DependentResource> list = new LinkedList<DependentResource>();
	Map<IResource, Depends> map = _dependsMap.get(dependsOn.getFullPath());
	ValManager vm = ValManager.getDefault();
	if (map != null){
	for (Map.Entry<IResource, Depends> me : map.entrySet()){
	for (String id : me.getValue().getValidatorsEnabled()){
	IResource res = me.getKey();
	Validator v = vm.getValidator(id, res.getProject());
	if (v != null)list.add(new DependentResource(res, v));
	}
	}
	}
	return list;
	}


	public synchronized void set(String id, IResource dependent, IResource[] dependsOn) {
	for (IResource d : dependsOn)add(id, dependent, d);
	}

	public boolean isDependedOn(IResource resource) {
	init();
	return _dependsMap.containsKey(resource.getFullPath());
	}

	public void doneSaving(ISaveContext context) {
	}

	public void prepareToSave(ISaveContext context) throws CoreException {
	}

	public void rollback(ISaveContext context) {
	}

	/**
	* Persist the dependency index.
	* <p>
	* The format of the index is:
	* <pre>
	* Version number
	* Number of depends on entries
	* depends on file name
	* number of dependent entries
	* dependent file name
	* number of validators
	* validator id
	* </pre>
	*/
	public void saving(ISaveContext context) throws CoreException {
	if (!_dirty)return;
	_dirty = false;

	DataOutputStream out = null;
	try {
	File f = getIndexLocation();
	out = new DataOutputStream(new FileOutputStream(f));
	out.writeInt(CurrentVersion);
	out.writeInt(_dependsMap.size());
	for (Map.Entry<IPath, Map<IResource, Depends>> me : _dependsMap.entrySet()){
	IPath key = me.getKey();
	out.writeUTF(key.toString());
	Map<IResource, Depends> map = me.getValue();
	out.writeInt(map.size());
	for (Map.Entry<IResource, Depends> me2: map.entrySet()){
	int vc = me2.getValue().validatorCount();
	if (vc == 0)continue;

	IResource key2 = me2.getKey();
	out.writeUTF(key2.getFullPath().toString());
	Map<String, Boolean> map3 = me2.getValue().getValidators();
	out.writeInt(vc);
	for (Map.Entry<String, Boolean> me3 : map3.entrySet()){
	if (me3.getValue())out.writeUTF(me3.getKey());
	}
	}
	}
	}
	catch (IOException e){
	ValidationPlugin.getPlugin().handleException(e);
	}
	finally {
	Misc.close(out);
	}
	}

	private File getIndexLocation() {
	IPath path = ValidationPlugin.getPlugin().getStateLocation().append("dep.index"); //$NON-NLS-1$
	return path.toFile();
	}

	private static class Depends {

	/** The key is the validator dependencyId.*/
	private Map<String, Boolean> _validators;

	private Depends(){
	_validators = new HashMap<String, Boolean>(5);
	}

	private Map<String, Boolean> getValidators() {
	return _validators;
	}

	/**
	* Answer the validator id's that are still enabled.
	* @return
	*/
	private List<String> getValidatorsEnabled() {
	List<String> list = new LinkedList<String>();
	for (Map.Entry<String, Boolean> me : _validators.entrySet()){
	if (me.getValue())list.add(me.getKey());
	}
	return list;
	}

	private void delete() {
	_validators.clear();
	}

	private void add(String id) {
	_validators.put(id, Boolean.TRUE);

	}

	private boolean hasValidator(String id) {
	Boolean v = _validators.get(id);
	if (v == null)return false;
	return v.booleanValue();
	}

	/**
	* Answer the number of active dependencies.
	* @return
	*/
	private int validatorCount(){
	int count = 0;
	for (Boolean b : _validators.values()){
	if (b)count++;
	}
	return count;
	}

	}


	}