bundles/org.eclipse.core.resources.semantic/src/org/eclipse/core/internal/resources/semantic/SemanticFileSystem.java - gerrit/e4/org.eclipse.e4.resources - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 SAP AG.
  * 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:
  *    Eduard Bartsch (SAP AG) - initial API and implementation
  *    Mathias Kinzler (SAP AG) - initial API and implementation
  *******************************************************************************/
 package org.eclipse.core.internal.resources.semantic;

 import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 import org.eclipse.core.filesystem.EFS;
 import org.eclipse.core.filesystem.IFileStore;
 import org.eclipse.core.filesystem.provider.FileSystem;
 import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.ResourceTreeNode;
 import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.SemanticResourceDBFactory;
 import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.TreeNodeType;
 import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.TreeRoot;
 import org.eclipse.core.internal.resources.semantic.util.ISemanticFileSystemLog;
 import org.eclipse.core.resources.semantic.ISemanticFileSystem;
 import org.eclipse.core.resources.semantic.ISemanticURILocatorService;
 import org.eclipse.core.resources.semantic.SemanticResourceException;
 import org.eclipse.core.resources.semantic.SemanticResourceStatusCode;
 import org.eclipse.core.resources.semantic.spi.ISemanticContentProvider;
 import org.eclipse.core.resources.semantic.spi.ISemanticContentProviderFederation;
 import org.eclipse.core.resources.semantic.spi.ISemanticFileStore;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource.Diagnostic;

 /**
  * The Semantic File System.
  * <p>
  * In order to access specific methods, this may be cast to
  * {@link ISemanticFileSystem}.
  *
  */
 public class SemanticFileSystem extends FileSystem implements ISemanticFileSystem {

 	private static final String METADATA_FILENAME = "metadata.xmi"; //$NON-NLS-1$
 	final static IPath EMPTY = new Path(""); //$NON-NLS-1$

 	private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
 	private final Lock readLock = this.rwl.readLock();
 	private final Lock writeLock = this.rwl.writeLock();
 	private final ISemanticFileSystemLog log;

 	SemanticMetadataPersistenceManager mgr;
 	private File metadataFolder;

 	private SemanticURILocatorService uriLocator;

 	/**
 	 * No-argument constructor
 	 */
 	public SemanticFileSystem() {

 		this.log = new SemanticFileSystemLog();

 		init(null);
 	}

 	public SemanticFileSystem(File rootFolder) {

 		this.log = new SemanticFileSystemLog();

 		init(rootFolder);
 	}

 	public String[] getRootNames() throws CoreException {

 		if (this.mgr.getSemanticDB() == null) {
 			throw new SemanticResourceException(SemanticResourceStatusCode.SFS_DB_NOT_INITIALIZED, SemanticFileSystem.EMPTY,
 					Messages.SemanticFileSystem_NotInitialized_XMSG);
 		}

 		List<String> result = new ArrayList<String>();

 		try {
 			lockForRead();

 			EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

 			for (TreeRoot treeRoot : roots) {
 				result.add(treeRoot.getName());
 			}
 		} finally {
 			unlockForRead();
 		}
 		return result.toArray(new String[0]);
 	}

 	/**
 	 * Requests a database update.
 	 *
 	 * @param force
 	 *            <code>true</code> for immediate update
 	 * @throws CoreException
 	 *             in case of failure
 	 */
 	public void requestFlush(boolean force, ResourceTreeNode node) throws CoreException {
 		node = getHighestParent(node);

 		saveSemanticDB(node.getName());
 	}

 	public ResourceTreeNode getHighestParent(ResourceTreeNode node) {
 		ResourceTreeNode parent = node.getParent();
 		while (parent != null) {
 			node = parent;
 			parent = node.getParent();
 		}
 		return node;
 	}

 	@Override
 	public IFileStore getStore(URI uri) {
 		if (ISemanticFileSystem.SCHEME.equals(uri.getScheme())) {
 			return getFileStoreImplementation(uri);
 		}
 		return EFS.getNullFileSystem().getStore(uri);
 	}

 	IFileStore getFileStoreImplementation(String pathString, String queryString) {
 		IPath path;

 		if (pathString != null) {
 			path = new Path(null, pathString);
 		} else {
 			path = Path.EMPTY;
 		}

 		if (this.mgr.getSemanticDB() == null) {
 			return EFS.getNullFileSystem().getStore(path);
 		}

 		ISemanticFileStore store;
 		// we do never return the virtual root node ("semanticfs:/")
 		if (path.segmentCount() > 0) {
 			try {
 				lockForWrite();

 				EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

 				TreeRoot treeRoot = null;

 				for (TreeRoot root : roots) {
 					if (path.segment(0).equals(root.getName())) {
 						if (path.segmentCount() == 1) {
 							return getStore(root);
 						}
 						treeRoot = root;
 						break;
 					}
 				}

 				if (treeRoot == null) {
 					if (path.segmentCount() == 1) {
 						treeRoot = createRootNode(path.segment(0), queryString);
 						return getStore(treeRoot);
 					}
 					treeRoot = createRootNode(path.segment(0));
 				}

 				store = (ISemanticFileStore) getFileStoreRecursive(path, treeRoot, queryString);
 			} finally {
 				unlockForWrite();
 			}

 			if (!store.isExists() && queryString != null) {
 				SemanticQueryParser parser = new SemanticQueryParser(queryString);

 				if (parser.getShouldCreate()) {
 					try {
 						if (parser.getType().equals(TreeNodeType.FOLDER) || parser.getType().equals(TreeNodeType.PROJECT)) {
 							store.mkdir(EFS.NONE, new NullProgressMonitor());
 						} else if (parser.getType().equals(TreeNodeType.FILE)) {
 							ISemanticFileStore parent = (ISemanticFileStore) store.getParent();

 							parent.mkdir(EFS.NONE, new NullProgressMonitor());

 							((ISemanticFileStoreInternal) parent).addResource(path.lastSegment(), false, parser.getProviderID(), null,
 									new NullProgressMonitor());

 							ISemanticFileStoreInternal child = ((ISemanticFileStoreInternal) parent).getChildResource(path.lastSegment());

 							child.setRemoteURI(new URI(parser.getURI()), new NullProgressMonitor());
 						}

 						return store;
 					} catch (CoreException e) {
 						return EFS.getNullFileSystem().getStore(path);
 					} catch (URISyntaxException e) {
 						return EFS.getNullFileSystem().getStore(path);
 					}
 				}
 			}
 			return store;
 		}

 		return EFS.getNullFileSystem().getStore(path);
 	}

 	private IFileStore getFileStoreImplementation(URI uri) {
 		String pathString = uri.getPath();
 		String queryString = uri.getQuery();
 		return getFileStoreImplementation(pathString, queryString);
 	}

 	private IFileStore getFileStoreRecursive(IPath path, ResourceTreeNode rootNode, String queryString) {
 		String[] segments = path.segments();
 		ResourceTreeNode currentNode = rootNode;
 		boolean ready = true;

 		for (int i = 1; i < segments.length; i++) {
 			String name = segments[i];
 			EList<ResourceTreeNode> children = currentNode.getChildren();
 			boolean found = false;

 			for (ResourceTreeNode resourceTreeNode : children) {
 				if (resourceTreeNode.getName().equals(name)) {
 					currentNode = resourceTreeNode;
 					found = true;
 					break;
 				}
 			}
 			if (!found) {
 				ready = false;
 				break;
 			}
 		}
 		if (ready) {
 			return getStore(currentNode);
 		}

 		ResourceTreeNode newNode = createNonExistingNode(path);

 		if (queryString != null) {
 			SemanticQueryParser parser = new SemanticQueryParser(queryString);

 			applyQueryParameters(newNode, parser);
 		}

 		return getStore(newNode);
 	}

 	ResourceTreeNode getParentNode(ResourceTreeNode childNode) {
 		try {
 			this.lockForRead();

 			if (childNode.isExists()) {
 				return childNode.getParent();
 			}

 			if (childNode.getPath() != null) {
 				int idx = childNode.getPath().lastIndexOf("/"); //$NON-NLS-1$
 				if (idx >= 0) {
 					String parentPath = childNode.getPath().substring(0, idx);
 					return this.getNodeByPath(parentPath);
 				}
 			}
 		} finally {
 			this.unlockForRead();
 		}
 		return null;
 	}

 	public List<ResourceTreeNode> getNodesByPath(String pathString) {
 		ArrayList<ResourceTreeNode> nodes = new ArrayList<ResourceTreeNode>();
 		IPath path = new Path(null, pathString);

 		if (path.segmentCount() > 0) {
 			try {
 				lockForRead();

 				if (this.mgr.getSemanticDB() != null) {
 					EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

 					for (TreeRoot treeRoot : roots) {
 						if (path.segment(0).equals(treeRoot.getName())) {
 							nodes.add(treeRoot);

 							if (path.segmentCount() == 1) {
 								return nodes;
 							}

 							ResourceTreeNode currentNode = treeRoot;
 							boolean withinExistingTree = true;

 							for (int i = 1; i < path.segmentCount(); i++) {
 								String name = path.segment(i);

 								if (withinExistingTree) {
 									EList<ResourceTreeNode> children = currentNode.getChildren();
 									boolean found = false;
 									for (ResourceTreeNode resourceTreeNode : children) {
 										if (resourceTreeNode.getName().equals(name)) {
 											currentNode = resourceTreeNode;
 											found = true;
 											break;
 										}
 									}

 									if (!found) {
 										currentNode = createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1));
 										withinExistingTree = false;
 									}
 								} else {
 									currentNode = createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1));
 								}

 								nodes.add(currentNode);
 							}
 							return nodes;
 						}
 					}
 				}

 				// no root found, create new node hierarchy outside the tree
 				nodes.add(createRootNode(path.segment(0)));

 				for (int i = 1; i < path.segmentCount(); i++) {
 					nodes.add(createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1)));
 				}
 			} finally {
 				unlockForRead();
 			}
 		}

 		return nodes;
 	}

 	ResourceTreeNode getNodeByPath(String pathString) {
 		IPath path = new Path(null, pathString);

 		// we do never return the virtual root node ("semanticfs:/")
 		if (path.segmentCount() > 0) {
 			try {
 				lockForRead();

 				if (this.mgr.getSemanticDB() != null) {
 					EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

 					for (TreeRoot treeRoot : roots) {
 						if (path.segment(0).equals(treeRoot.getName())) {
 							if (path.segmentCount() == 1) {
 								return treeRoot;
 							}

 							String[] segments = path.segments();
 							ResourceTreeNode currentNode = treeRoot;
 							boolean ready = true;

 							for (int i = 1; i < segments.length; i++) {
 								String name = segments[i];
 								EList<ResourceTreeNode> children = currentNode.getChildren();
 								boolean found = false;

 								for (ResourceTreeNode resourceTreeNode : children) {
 									if (resourceTreeNode.getName().equals(name)) {
 										currentNode = resourceTreeNode;
 										found = true;
 										break;
 									}
 								}
 								if (!found) {
 									ready = false;
 									break;
 								}
 							}
 							if (ready) {
 								return currentNode;
 							}
 							return createNonExistingNode(path);
 						}
 					}
 				}
 			} finally {
 				unlockForRead();
 			}

 			// no root found, create new node outside the tree
 			if (path.segmentCount() == 1) {
 				return createRootNode(path.segment(0));
 			}

 			return createNonExistingNode(path);
 		}

 		return null;
 	}

 	ISemanticContentProvider mkdir(ResourceTreeNode actNode, ResourceTreeNode parent) throws CoreException {
 		ISemanticContentProvider parentProvider = null;

 		if (parent != null && !parent.isExists()) {
 			ResourceTreeNode parentParent = this.getParentNode(parent);
 			parentProvider = mkdir(parent, parentParent);
 		} else if (parent != null) { // and exists
 			parentProvider = this.getStore(parent).getEffectiveContentProvider();
 		} else { // parent == null
 			parentProvider = this.getStore(actNode).getEffectiveContentProvider();
 		}

 		return makeFolder(actNode, parent, parentProvider);
 	}

 	ISemanticContentProvider makeFolder(ResourceTreeNode actNode, ResourceTreeNode parent, ISemanticContentProvider parentProvider)
 			throws CoreException {
 		ISemanticContentProvider effectiveProvider = parentProvider;
 		String federatedContentProviderId = null;

 		if (actNode.getType() == TreeNodeType.FILE) {
 			// wrong type encountered
 			throw new SemanticResourceException(SemanticResourceStatusCode.RESOURCE_WITH_OTHER_TYPE_EXISTS, this.getStore(actNode)
 					.getPath(), Messages.SemanticFileStore_MkDirOnFile_XMSG);
 		}

 		boolean bExistedBefore = actNode.isExists();

 		if (!actNode.isExists() && actNode.getTemplateID() == null) {
 			if (parentProvider instanceof ISemanticContentProviderFederation) {
 				federatedContentProviderId = ((ISemanticContentProviderFederation) parentProvider).getFederatedProviderIDForPath(new Path(
 						actNode.getPath()));
 			}

 			actNode.setTemplateID(federatedContentProviderId);

 		}

 		// TODO 0.2: this should be intercepted by the content provider to
 		// avoid unwanted folder creation
 		this.switchToExists(actNode, parent);

 		if (actNode.getType() != TreeNodeType.PROJECT) {
 			// set type folder if it is not already a project
 			actNode.setType(TreeNodeType.FOLDER);
 		}

 		if (actNode.getTemplateID() != null) {
 			ISemanticFileStore newStore = this.getStore(actNode);
 			effectiveProvider = newStore.getEffectiveContentProvider();

 			if (!bExistedBefore) {
 				effectiveProvider.onRootStoreCreate(newStore);
 			}
 		}
 		return effectiveProvider;
 	}

 	void switchToExists(ResourceTreeNode node, ResourceTreeNode parent) {
 		if (!node.isExists()) {
 			if (node instanceof TreeRoot) {
 				((TreeRoot) node).setParentDB(this.mgr.getSemanticDB());
 			} else {

 				if (parent != null) {
 					node.setParent(parent);
 				}
 			}

 			node.setPath(null);
 			node.setExists(true);
 		}
 	}

 	private ResourceTreeNode createNonExistingNode(IPath childPath) {
 		// all callers have a lock, so we don't lock here
 		ResourceTreeNode child = SemanticResourceDBFactory.eINSTANCE.createResourceTreeNode();

 		child.setName(childPath.lastSegment());
 		child.setType(TreeNodeType.UNKNOWN);
 		child.setExists(false);
 		child.setPath(childPath.toString());
 		child.setLocalOnly(true);

 		return child;
 	}

 	public IPath getPathForNode(ResourceTreeNode node) {
 		try {
 			lockForRead();
 			if (node.isExists()) {
 				StringBuilder sb = new StringBuilder(50);
 				sb.append('/');
 				sb.append(node.getName());
 				ResourceTreeNode parent = node.getParent();
 				while (parent != null) {
 					sb.insert(0, parent.getName());
 					sb.insert(0, '/');
 					parent = parent.getParent();
 				}
 				return new Path(sb.toString());
 			}
 			if (node.getPath() != null) {
 				return new Path(node.getPath());
 			}

 			return EMPTY;
 		} finally {
 			unlockForRead();
 		}
 	}

 	protected ISemanticFileStore getStore(ResourceTreeNode node) {
 		return new SemanticFileStore(this, node);
 	}

 	private void init(File rootFolder) {
 		if (rootFolder != null) {
 			this.metadataFolder = rootFolder;
 		} else {
 			this.metadataFolder = SemanticResourcesPlugin.getCacheLocation().toFile();
 		}

 		mgr = new SemanticMetadataPersistenceManager(metadataFolder);

 		try {
 			mgr.init();
 		} catch (IOException e) {
 			for (Diagnostic diagnostic : mgr.getMetadataResource().getErrors()) {
 				this.log.log(new SemanticResourceException(SemanticResourceStatusCode.SFS_INITIALIZATION_ERROR, SemanticFileSystem.EMPTY,
 						diagnostic.getMessage()));
 			}
 			this.log.log(new SemanticResourceException(SemanticResourceStatusCode.SFS_INITIALIZATION_ERROR, SemanticFileSystem.EMPTY,
 					Messages.SemanticFileSystem_SFSInitError_XMSG, e));

 		}
 	}

 	private TreeRoot createRootNode(String name) {
 		TreeRoot root = SemanticResourceDBFactory.eINSTANCE.createTreeRoot();

 		root.setName(name);
 		root.setExists(false);
 		root.setPath("/" + name); //$NON-NLS-1$
 		root.setType(TreeNodeType.PROJECT);
 		// root.setParentDB(this.db);

 		return root;
 	}

 	private TreeRoot createRootNode(String name, String queryString) {
 		TreeRoot root = SemanticResourceDBFactory.eINSTANCE.createTreeRoot();

 		root.setName(name);
 		root.setQueryPart(queryString);
 		root.setExists(false);
 		root.setPath("/" + name); //$NON-NLS-1$
 		root.setType(TreeNodeType.PROJECT);

 		if (queryString != null) {
 			SemanticQueryParser parser = new SemanticQueryParser(queryString);

 			applyQueryParameters(root, parser);

 			if (parser.getShouldCreate()) {
 				root.setExists(true);
 				root.setPath(null);
 				root.setParentDB(this.mgr.getSemanticDB());
 			}
 		}
 		return root;
 	}

 	private void applyQueryParameters(ResourceTreeNode node, SemanticQueryParser parser) {
 		node.setTemplateID(parser.getProviderID());
 		node.setType(parser.getType());
 		node.setRemoteURI(parser.getURI());
 	}

 	private void saveSemanticDB(String name) throws CoreException {
 		try {
 			if (SfsTraceLocation.CORE_DB.isActive()) {
 				SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_DB.getLocation());
 			}
 			try {
 				this.lockForWrite();

 				this.mgr.saveSemanticDB(name);
 			} finally {
 				this.unlockForWrite();
 			}
 		} catch (IOException e) {
 			SemanticResourceException ex = new SemanticResourceException(SemanticResourceStatusCode.SFS_ERROR_WRITING_METADATA,
 					SemanticFileSystem.EMPTY, Messages.SemanticFileSystem_SFSUpdateError_XMSG, e);
 			throw ex;

 		}
 	}

 	protected void lockForRead() {
 		this.readLock.lock();
 	}

 	protected void unlockForRead() {
 		this.readLock.unlock();
 	}

 	protected void lockForWrite() {
 		this.writeLock.lock();
 	}

 	protected void unlockForWrite() {
 		this.writeLock.unlock();
 	}

 	public String getPathToDb() {
 		File metadataFile = new File(metadataFolder, SemanticFileSystem.METADATA_FILENAME);

 		String metadataLocation = metadataFile.getAbsolutePath();

 		return metadataLocation;
 	}

 	public ISemanticFileSystemLog getLog() {
 		return this.log;
 	}

 	static final class SemanticURILocatorService implements ISemanticURILocatorService {
 		private HashMap<String, ArrayList<IPath>> uri2pathMapping = new HashMap<String, ArrayList<IPath>>();
 		final SemanticFileSystem fs;
 		boolean needsRebuild;

 		/**
 		 * @param fs
 		 *
 		 */
 		public SemanticURILocatorService(SemanticFileSystem fs) {
 			this.fs = fs;
 		}

 		/**
 		 * @throws CoreException
 		 */
 		public IPath[] locateURI(URI uri) throws CoreException {
 			try {
 				this.fs.lockForWrite();

 				if (this.needsRebuild) {
 					this.rebuildMapping(null);
 				}

 				ArrayList<IPath> paths = this.uri2pathMapping.get(uri.toString());
 				if (paths != null) {
 					return paths.toArray(new IPath[paths.size()]);
 				}
 				return new IPath[0];
 			} finally {
 				this.fs.unlockForWrite();
 			}
 		}

 		/**
 		 * @throws CoreException
 		 */
 		public IPath[] locateURI(URI uri, IPath rootpath) throws CoreException {
 			try {
 				this.fs.lockForWrite();

 				if (this.needsRebuild) {
 					this.rebuildMapping(null);
 				}

 				ArrayList<IPath> paths = this.uri2pathMapping.get(uri.toString());
 				if (paths != null) {
 					ArrayList<IPath> filteredpaths = new ArrayList<IPath>();

 					for (IPath iPath : paths) {
 						if (rootpath.isPrefixOf(iPath)) {
 							filteredpaths.add(iPath);
 						}
 					}

 					return filteredpaths.toArray(new IPath[filteredpaths.size()]);
 				}
 				return new IPath[0];
 			} finally {
 				this.fs.unlockForWrite();
 			}
 		}

 		public IPath getPathForNode(ResourceTreeNode node) {
 			return this.fs.getPathForNode(node);
 		}

 		public void rebuildMapping(IProgressMonitor monitor) {
 			this.uri2pathMapping.clear();

 			TreeIterator<EObject> contents = this.fs.mgr.getMetadataResource().getAllContents();

 			while (contents.hasNext()) {
 				EObject eObject = contents.next();
 				if (eObject instanceof ResourceTreeNode) {
 					ResourceTreeNode node = (ResourceTreeNode) eObject;

 					String uriString = node.getRemoteURI();

 					if (uriString != null) {
 						addURI(getPathForNode(node), uriString);
 					}
 				}
 			}
 			this.needsRebuild = false;
 		}

 		public void addURI(IPath path, String uriString) {
 			ArrayList<IPath> paths = this.uri2pathMapping.get(uriString);

 			if (paths != null) {
 				paths.add(path);
 			} else {
 				paths = new ArrayList<IPath>();

 				paths.add(path);
 				this.uri2pathMapping.put(uriString, paths);
 			}
 		}

 		public void removeURI(IPath path, String uriString) {
 			ArrayList<IPath> paths = this.uri2pathMapping.get(uriString);

 			paths.remove(path);

 			if (paths.isEmpty()) {
 				this.uri2pathMapping.remove(uriString);
 			}
 		}

 		public void requestRebuild() {
 			this.needsRebuild = true;
 		}

 	}

 	/**
 	 * @throws CoreException
 	 */
 	public ISemanticURILocatorService getURILocatorService(IProgressMonitor monitor) throws CoreException {
 		try {
 			this.lockForWrite();
 			if (this.uriLocator == null) {
 				this.uriLocator = new SemanticURILocatorService(this);

 				this.uriLocator.rebuildMapping(monitor);
 			}
 			return this.uriLocator;
 		} finally {
 			this.unlockForWrite();
 		}
 	}

 	/**
 	 *
 	 */
 	public void requestURILocatorRebuild() {
 		if (this.uriLocator != null) {
 			this.uriLocator.requestRebuild();
 		}
 	}

 	public SemanticURILocatorService getURILocator() {
 		return this.uriLocator;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009 SAP AG.
	* 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:
	* Eduard Bartsch (SAP AG) - initial API and implementation
	* Mathias Kinzler (SAP AG) - initial API and implementation
	*******************************************************************************/
	package org.eclipse.core.internal.resources.semantic;

	import java.io.File;
	import java.io.IOException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.concurrent.locks.Lock;
	import java.util.concurrent.locks.ReentrantReadWriteLock;

	import org.eclipse.core.filesystem.EFS;
	import org.eclipse.core.filesystem.IFileStore;
	import org.eclipse.core.filesystem.provider.FileSystem;
	import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.ResourceTreeNode;
	import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.SemanticResourceDBFactory;
	import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.TreeNodeType;
	import org.eclipse.core.internal.resources.semantic.model.SemanticResourceDB.TreeRoot;
	import org.eclipse.core.internal.resources.semantic.util.ISemanticFileSystemLog;
	import org.eclipse.core.resources.semantic.ISemanticFileSystem;
	import org.eclipse.core.resources.semantic.ISemanticURILocatorService;
	import org.eclipse.core.resources.semantic.SemanticResourceException;
	import org.eclipse.core.resources.semantic.SemanticResourceStatusCode;
	import org.eclipse.core.resources.semantic.spi.ISemanticContentProvider;
	import org.eclipse.core.resources.semantic.spi.ISemanticContentProviderFederation;
	import org.eclipse.core.resources.semantic.spi.ISemanticFileStore;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.TreeIterator;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource.Diagnostic;

	/**
	* The Semantic File System.
	* <p>
	* In order to access specific methods, this may be cast to
	* {@link ISemanticFileSystem}.
	*
	*/
	public class SemanticFileSystem extends FileSystem implements ISemanticFileSystem {

	private static final String METADATA_FILENAME = "metadata.xmi"; //$NON-NLS-1$
	final static IPath EMPTY = new Path(""); //$NON-NLS-1$

	private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	private final Lock readLock = this.rwl.readLock();
	private final Lock writeLock = this.rwl.writeLock();
	private final ISemanticFileSystemLog log;

	SemanticMetadataPersistenceManager mgr;
	private File metadataFolder;

	private SemanticURILocatorService uriLocator;

	/**
	* No-argument constructor
	*/
	public SemanticFileSystem() {

	this.log = new SemanticFileSystemLog();

	init(null);
	}

	public SemanticFileSystem(File rootFolder) {

	this.log = new SemanticFileSystemLog();

	init(rootFolder);
	}

	public String[] getRootNames() throws CoreException {

	if (this.mgr.getSemanticDB() == null) {
	throw new SemanticResourceException(SemanticResourceStatusCode.SFS_DB_NOT_INITIALIZED, SemanticFileSystem.EMPTY,
	Messages.SemanticFileSystem_NotInitialized_XMSG);
	}

	List<String> result = new ArrayList<String>();

	try {
	lockForRead();

	EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

	for (TreeRoot treeRoot : roots) {
	result.add(treeRoot.getName());
	}
	} finally {
	unlockForRead();
	}
	return result.toArray(new String[0]);
	}

	/**
	* Requests a database update.
	*
	* @param force
	* <code>true</code> for immediate update
	* @throws CoreException
	* in case of failure
	*/
	public void requestFlush(boolean force, ResourceTreeNode node) throws CoreException {
	node = getHighestParent(node);

	saveSemanticDB(node.getName());
	}

	public ResourceTreeNode getHighestParent(ResourceTreeNode node) {
	ResourceTreeNode parent = node.getParent();
	while (parent != null) {
	node = parent;
	parent = node.getParent();
	}
	return node;
	}

	@Override
	public IFileStore getStore(URI uri) {
	if (ISemanticFileSystem.SCHEME.equals(uri.getScheme())) {
	return getFileStoreImplementation(uri);
	}
	return EFS.getNullFileSystem().getStore(uri);
	}

	IFileStore getFileStoreImplementation(String pathString, String queryString) {
	IPath path;

	if (pathString != null) {
	path = new Path(null, pathString);
	} else {
	path = Path.EMPTY;
	}

	if (this.mgr.getSemanticDB() == null) {
	return EFS.getNullFileSystem().getStore(path);
	}

	ISemanticFileStore store;
	// we do never return the virtual root node ("semanticfs:/")
	if (path.segmentCount() > 0) {
	try {
	lockForWrite();

	EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

	TreeRoot treeRoot = null;

	for (TreeRoot root : roots) {
	if (path.segment(0).equals(root.getName())) {
	if (path.segmentCount() == 1) {
	return getStore(root);
	}
	treeRoot = root;
	break;
	}
	}

	if (treeRoot == null) {
	if (path.segmentCount() == 1) {
	treeRoot = createRootNode(path.segment(0), queryString);
	return getStore(treeRoot);
	}
	treeRoot = createRootNode(path.segment(0));
	}

	store = (ISemanticFileStore) getFileStoreRecursive(path, treeRoot, queryString);
	} finally {
	unlockForWrite();
	}

	if (!store.isExists() && queryString != null) {
	SemanticQueryParser parser = new SemanticQueryParser(queryString);

	if (parser.getShouldCreate()) {
	try {
	if (parser.getType().equals(TreeNodeType.FOLDER) \|\| parser.getType().equals(TreeNodeType.PROJECT)) {
	store.mkdir(EFS.NONE, new NullProgressMonitor());
	} else if (parser.getType().equals(TreeNodeType.FILE)) {
	ISemanticFileStore parent = (ISemanticFileStore) store.getParent();

	parent.mkdir(EFS.NONE, new NullProgressMonitor());

	((ISemanticFileStoreInternal) parent).addResource(path.lastSegment(), false, parser.getProviderID(), null,
	new NullProgressMonitor());

	ISemanticFileStoreInternal child = ((ISemanticFileStoreInternal) parent).getChildResource(path.lastSegment());

	child.setRemoteURI(new URI(parser.getURI()), new NullProgressMonitor());
	}

	return store;
	} catch (CoreException e) {
	return EFS.getNullFileSystem().getStore(path);
	} catch (URISyntaxException e) {
	return EFS.getNullFileSystem().getStore(path);
	}
	}
	}
	return store;
	}

	return EFS.getNullFileSystem().getStore(path);
	}

	private IFileStore getFileStoreImplementation(URI uri) {
	String pathString = uri.getPath();
	String queryString = uri.getQuery();
	return getFileStoreImplementation(pathString, queryString);
	}

	private IFileStore getFileStoreRecursive(IPath path, ResourceTreeNode rootNode, String queryString) {
	String[] segments = path.segments();
	ResourceTreeNode currentNode = rootNode;
	boolean ready = true;

	for (int i = 1; i < segments.length; i++) {
	String name = segments[i];
	EList<ResourceTreeNode> children = currentNode.getChildren();
	boolean found = false;

	for (ResourceTreeNode resourceTreeNode : children) {
	if (resourceTreeNode.getName().equals(name)) {
	currentNode = resourceTreeNode;
	found = true;
	break;
	}
	}
	if (!found) {
	ready = false;
	break;
	}
	}
	if (ready) {
	return getStore(currentNode);
	}

	ResourceTreeNode newNode = createNonExistingNode(path);

	if (queryString != null) {
	SemanticQueryParser parser = new SemanticQueryParser(queryString);

	applyQueryParameters(newNode, parser);
	}

	return getStore(newNode);
	}

	ResourceTreeNode getParentNode(ResourceTreeNode childNode) {
	try {
	this.lockForRead();

	if (childNode.isExists()) {
	return childNode.getParent();
	}

	if (childNode.getPath() != null) {
	int idx = childNode.getPath().lastIndexOf("/"); //$NON-NLS-1$
	if (idx >= 0) {
	String parentPath = childNode.getPath().substring(0, idx);
	return this.getNodeByPath(parentPath);
	}
	}
	} finally {
	this.unlockForRead();
	}
	return null;
	}

	public List<ResourceTreeNode> getNodesByPath(String pathString) {
	ArrayList<ResourceTreeNode> nodes = new ArrayList<ResourceTreeNode>();
	IPath path = new Path(null, pathString);

	if (path.segmentCount() > 0) {
	try {
	lockForRead();

	if (this.mgr.getSemanticDB() != null) {
	EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

	for (TreeRoot treeRoot : roots) {
	if (path.segment(0).equals(treeRoot.getName())) {
	nodes.add(treeRoot);

	if (path.segmentCount() == 1) {
	return nodes;
	}

	ResourceTreeNode currentNode = treeRoot;
	boolean withinExistingTree = true;

	for (int i = 1; i < path.segmentCount(); i++) {
	String name = path.segment(i);

	if (withinExistingTree) {
	EList<ResourceTreeNode> children = currentNode.getChildren();
	boolean found = false;
	for (ResourceTreeNode resourceTreeNode : children) {
	if (resourceTreeNode.getName().equals(name)) {
	currentNode = resourceTreeNode;
	found = true;
	break;
	}
	}

	if (!found) {
	currentNode = createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1));
	withinExistingTree = false;
	}
	} else {
	currentNode = createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1));
	}

	nodes.add(currentNode);
	}
	return nodes;
	}
	}
	}

	// no root found, create new node hierarchy outside the tree
	nodes.add(createRootNode(path.segment(0)));

	for (int i = 1; i < path.segmentCount(); i++) {
	nodes.add(createNonExistingNode(path.removeLastSegments(path.segmentCount() - i - 1)));
	}
	} finally {
	unlockForRead();
	}
	}

	return nodes;
	}

	ResourceTreeNode getNodeByPath(String pathString) {
	IPath path = new Path(null, pathString);

	// we do never return the virtual root node ("semanticfs:/")
	if (path.segmentCount() > 0) {
	try {
	lockForRead();

	if (this.mgr.getSemanticDB() != null) {
	EList<TreeRoot> roots = this.mgr.getSemanticDB().getRoots();

	for (TreeRoot treeRoot : roots) {
	if (path.segment(0).equals(treeRoot.getName())) {
	if (path.segmentCount() == 1) {
	return treeRoot;
	}

	String[] segments = path.segments();
	ResourceTreeNode currentNode = treeRoot;
	boolean ready = true;

	for (int i = 1; i < segments.length; i++) {
	String name = segments[i];
	EList<ResourceTreeNode> children = currentNode.getChildren();
	boolean found = false;

	for (ResourceTreeNode resourceTreeNode : children) {
	if (resourceTreeNode.getName().equals(name)) {
	currentNode = resourceTreeNode;
	found = true;
	break;
	}
	}
	if (!found) {
	ready = false;
	break;
	}
	}
	if (ready) {
	return currentNode;
	}
	return createNonExistingNode(path);
	}
	}
	}
	} finally {
	unlockForRead();
	}

	// no root found, create new node outside the tree
	if (path.segmentCount() == 1) {
	return createRootNode(path.segment(0));
	}

	return createNonExistingNode(path);
	}

	return null;
	}

	ISemanticContentProvider mkdir(ResourceTreeNode actNode, ResourceTreeNode parent) throws CoreException {
	ISemanticContentProvider parentProvider = null;

	if (parent != null && !parent.isExists()) {
	ResourceTreeNode parentParent = this.getParentNode(parent);
	parentProvider = mkdir(parent, parentParent);
	} else if (parent != null) { // and exists
	parentProvider = this.getStore(parent).getEffectiveContentProvider();
	} else { // parent == null
	parentProvider = this.getStore(actNode).getEffectiveContentProvider();
	}

	return makeFolder(actNode, parent, parentProvider);
	}

	ISemanticContentProvider makeFolder(ResourceTreeNode actNode, ResourceTreeNode parent, ISemanticContentProvider parentProvider)
	throws CoreException {
	ISemanticContentProvider effectiveProvider = parentProvider;
	String federatedContentProviderId = null;

	if (actNode.getType() == TreeNodeType.FILE) {
	// wrong type encountered
	throw new SemanticResourceException(SemanticResourceStatusCode.RESOURCE_WITH_OTHER_TYPE_EXISTS, this.getStore(actNode)
	.getPath(), Messages.SemanticFileStore_MkDirOnFile_XMSG);
	}

	boolean bExistedBefore = actNode.isExists();

	if (!actNode.isExists() && actNode.getTemplateID() == null) {
	if (parentProvider instanceof ISemanticContentProviderFederation) {
	federatedContentProviderId = ((ISemanticContentProviderFederation) parentProvider).getFederatedProviderIDForPath(new Path(
	actNode.getPath()));
	}

	actNode.setTemplateID(federatedContentProviderId);

	}

	// TODO 0.2: this should be intercepted by the content provider to
	// avoid unwanted folder creation
	this.switchToExists(actNode, parent);

	if (actNode.getType() != TreeNodeType.PROJECT) {
	// set type folder if it is not already a project
	actNode.setType(TreeNodeType.FOLDER);
	}

	if (actNode.getTemplateID() != null) {
	ISemanticFileStore newStore = this.getStore(actNode);
	effectiveProvider = newStore.getEffectiveContentProvider();

	if (!bExistedBefore) {
	effectiveProvider.onRootStoreCreate(newStore);
	}
	}
	return effectiveProvider;
	}

	void switchToExists(ResourceTreeNode node, ResourceTreeNode parent) {
	if (!node.isExists()) {
	if (node instanceof TreeRoot) {
	((TreeRoot) node).setParentDB(this.mgr.getSemanticDB());
	} else {

	if (parent != null) {
	node.setParent(parent);
	}
	}

	node.setPath(null);
	node.setExists(true);
	}
	}

	private ResourceTreeNode createNonExistingNode(IPath childPath) {
	// all callers have a lock, so we don't lock here
	ResourceTreeNode child = SemanticResourceDBFactory.eINSTANCE.createResourceTreeNode();

	child.setName(childPath.lastSegment());
	child.setType(TreeNodeType.UNKNOWN);
	child.setExists(false);
	child.setPath(childPath.toString());
	child.setLocalOnly(true);

	return child;
	}

	public IPath getPathForNode(ResourceTreeNode node) {
	try {
	lockForRead();
	if (node.isExists()) {
	StringBuilder sb = new StringBuilder(50);
	sb.append('/');
	sb.append(node.getName());
	ResourceTreeNode parent = node.getParent();
	while (parent != null) {
	sb.insert(0, parent.getName());
	sb.insert(0, '/');
	parent = parent.getParent();
	}
	return new Path(sb.toString());
	}
	if (node.getPath() != null) {
	return new Path(node.getPath());
	}

	return EMPTY;
	} finally {
	unlockForRead();
	}
	}

	protected ISemanticFileStore getStore(ResourceTreeNode node) {
	return new SemanticFileStore(this, node);
	}

	private void init(File rootFolder) {
	if (rootFolder != null) {
	this.metadataFolder = rootFolder;
	} else {
	this.metadataFolder = SemanticResourcesPlugin.getCacheLocation().toFile();
	}

	mgr = new SemanticMetadataPersistenceManager(metadataFolder);

	try {
	mgr.init();
	} catch (IOException e) {
	for (Diagnostic diagnostic : mgr.getMetadataResource().getErrors()) {
	this.log.log(new SemanticResourceException(SemanticResourceStatusCode.SFS_INITIALIZATION_ERROR, SemanticFileSystem.EMPTY,
	diagnostic.getMessage()));
	}
	this.log.log(new SemanticResourceException(SemanticResourceStatusCode.SFS_INITIALIZATION_ERROR, SemanticFileSystem.EMPTY,
	Messages.SemanticFileSystem_SFSInitError_XMSG, e));

	}
	}

	private TreeRoot createRootNode(String name) {
	TreeRoot root = SemanticResourceDBFactory.eINSTANCE.createTreeRoot();

	root.setName(name);
	root.setExists(false);
	root.setPath("/" + name); //$NON-NLS-1$
	root.setType(TreeNodeType.PROJECT);
	// root.setParentDB(this.db);

	return root;
	}

	private TreeRoot createRootNode(String name, String queryString) {
	TreeRoot root = SemanticResourceDBFactory.eINSTANCE.createTreeRoot();

	root.setName(name);
	root.setQueryPart(queryString);
	root.setExists(false);
	root.setPath("/" + name); //$NON-NLS-1$
	root.setType(TreeNodeType.PROJECT);

	if (queryString != null) {
	SemanticQueryParser parser = new SemanticQueryParser(queryString);

	applyQueryParameters(root, parser);

	if (parser.getShouldCreate()) {
	root.setExists(true);
	root.setPath(null);
	root.setParentDB(this.mgr.getSemanticDB());
	}
	}
	return root;
	}

	private void applyQueryParameters(ResourceTreeNode node, SemanticQueryParser parser) {
	node.setTemplateID(parser.getProviderID());
	node.setType(parser.getType());
	node.setRemoteURI(parser.getURI());
	}

	private void saveSemanticDB(String name) throws CoreException {
	try {
	if (SfsTraceLocation.CORE_DB.isActive()) {
	SfsTraceLocation.getTrace().traceEntry(SfsTraceLocation.CORE_DB.getLocation());
	}
	try {
	this.lockForWrite();

	this.mgr.saveSemanticDB(name);
	} finally {
	this.unlockForWrite();
	}
	} catch (IOException e) {
	SemanticResourceException ex = new SemanticResourceException(SemanticResourceStatusCode.SFS_ERROR_WRITING_METADATA,
	SemanticFileSystem.EMPTY, Messages.SemanticFileSystem_SFSUpdateError_XMSG, e);
	throw ex;

	}
	}

	protected void lockForRead() {
	this.readLock.lock();
	}

	protected void unlockForRead() {
	this.readLock.unlock();
	}

	protected void lockForWrite() {
	this.writeLock.lock();
	}

	protected void unlockForWrite() {
	this.writeLock.unlock();
	}

	public String getPathToDb() {
	File metadataFile = new File(metadataFolder, SemanticFileSystem.METADATA_FILENAME);

	String metadataLocation = metadataFile.getAbsolutePath();

	return metadataLocation;
	}

	public ISemanticFileSystemLog getLog() {
	return this.log;
	}

	static final class SemanticURILocatorService implements ISemanticURILocatorService {
	private HashMap<String, ArrayList<IPath>> uri2pathMapping = new HashMap<String, ArrayList<IPath>>();
	final SemanticFileSystem fs;
	boolean needsRebuild;

	/**
	* @param fs
	*
	*/
	public SemanticURILocatorService(SemanticFileSystem fs) {
	this.fs = fs;
	}

	/**
	* @throws CoreException
	*/
	public IPath[] locateURI(URI uri) throws CoreException {
	try {
	this.fs.lockForWrite();

	if (this.needsRebuild) {
	this.rebuildMapping(null);
	}

	ArrayList<IPath> paths = this.uri2pathMapping.get(uri.toString());
	if (paths != null) {
	return paths.toArray(new IPath[paths.size()]);
	}
	return new IPath[0];
	} finally {
	this.fs.unlockForWrite();
	}
	}

	/**
	* @throws CoreException
	*/
	public IPath[] locateURI(URI uri, IPath rootpath) throws CoreException {
	try {
	this.fs.lockForWrite();

	if (this.needsRebuild) {
	this.rebuildMapping(null);
	}

	ArrayList<IPath> paths = this.uri2pathMapping.get(uri.toString());
	if (paths != null) {
	ArrayList<IPath> filteredpaths = new ArrayList<IPath>();

	for (IPath iPath : paths) {
	if (rootpath.isPrefixOf(iPath)) {
	filteredpaths.add(iPath);
	}
	}

	return filteredpaths.toArray(new IPath[filteredpaths.size()]);
	}
	return new IPath[0];
	} finally {
	this.fs.unlockForWrite();
	}
	}

	public IPath getPathForNode(ResourceTreeNode node) {
	return this.fs.getPathForNode(node);
	}

	public void rebuildMapping(IProgressMonitor monitor) {
	this.uri2pathMapping.clear();

	TreeIterator<EObject> contents = this.fs.mgr.getMetadataResource().getAllContents();

	while (contents.hasNext()) {
	EObject eObject = contents.next();
	if (eObject instanceof ResourceTreeNode) {
	ResourceTreeNode node = (ResourceTreeNode) eObject;

	String uriString = node.getRemoteURI();

	if (uriString != null) {
	addURI(getPathForNode(node), uriString);
	}
	}
	}
	this.needsRebuild = false;
	}

	public void addURI(IPath path, String uriString) {
	ArrayList<IPath> paths = this.uri2pathMapping.get(uriString);

	if (paths != null) {
	paths.add(path);
	} else {
	paths = new ArrayList<IPath>();

	paths.add(path);
	this.uri2pathMapping.put(uriString, paths);
	}
	}

	public void removeURI(IPath path, String uriString) {
	ArrayList<IPath> paths = this.uri2pathMapping.get(uriString);

	paths.remove(path);

	if (paths.isEmpty()) {
	this.uri2pathMapping.remove(uriString);
	}
	}

	public void requestRebuild() {
	this.needsRebuild = true;
	}

	}

	/**
	* @throws CoreException
	*/
	public ISemanticURILocatorService getURILocatorService(IProgressMonitor monitor) throws CoreException {
	try {
	this.lockForWrite();
	if (this.uriLocator == null) {
	this.uriLocator = new SemanticURILocatorService(this);

	this.uriLocator.rebuildMapping(monitor);
	}
	return this.uriLocator;
	} finally {
	this.unlockForWrite();
	}
	}

	/**
	*
	*/
	public void requestURILocatorRebuild() {
	if (this.uriLocator != null) {
	this.uriLocator.requestRebuild();
	}
	}

	public SemanticURILocatorService getURILocator() {
	return this.uriLocator;
	}
	}