path: root/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/logical/StreamAccessorStorage.java

/*******************************************************************************
 * Copyright (c) 2013, 2015 Obeo 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:
 *     Obeo - initial API and implementation
 *     Alexandra Buzila - bug 469105
 *******************************************************************************/
package org.eclipse.emf.compare.ide.ui.internal.logical;

import static org.eclipse.emf.compare.ide.ui.internal.util.PlatformElementUtil.adaptAs;
import static org.eclipse.emf.compare.ide.ui.internal.util.PlatformElementUtil.findFile;

import java.io.File;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;

import org.eclipse.compare.ISharedDocumentAdapter;
import org.eclipse.compare.IStreamContentAccessor;
import org.eclipse.compare.ITypedElement;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.compare.ide.internal.utils.StoragePathAdapter;
import org.eclipse.emf.compare.ide.utils.IStoragePathAdapterProvider;
import org.eclipse.emf.compare.ide.utils.IStoragePathProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.history.IFileRevision;
import org.eclipse.team.core.variants.CachedResourceVariant;
import org.eclipse.team.core.variants.IResourceVariant;
import org.eclipse.ui.IEditorInput;

/**
 * This implementation of IStorage simply wraps a stream content accessor.
 * 
 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>
 */
public class StreamAccessorStorage implements IStorage, IStoragePathAdapterProvider {
	/** The wrapped accessor. */
	private final IStreamContentAccessor accessor;

	/** Full path of the underlying content. */
	private final String fullPath;

	/**
	 * Wraps the given accessor.
	 * 
	 * @param accessor
	 *            The accessor to wrap as an IStorage.
	 * @param fullPath
	 *            Full path to the underlying storage.
	 */
	public StreamAccessorStorage(IStreamContentAccessor accessor, String fullPath) {
		this.accessor = accessor;
		this.fullPath = fullPath;
	}

	/**
	 * This is a short-hand for {@link #fromTypedElement(String, ITypedElement)}. This second one should be
	 * preferred in case the given element is remote and we need a proper path for it.
	 * 
	 * @param element
	 *            The typed element for which we need to create a wrapper.
	 * @return The wrapped typed element.
	 * @throws IllegalArgumentException
	 *             If the given element does not implement {@link IStreamContentAccessor}.
	 */
	public static StreamAccessorStorage fromTypedElement(ITypedElement element)
			throws IllegalArgumentException {
		return fromTypedElement(null, element);
	}

	/**
	 * Creates a StreamAccessorStorage given the input typed element. Note that the given typed element -must-
	 * implement {@link IStreamContentAccessor} as well.
	 * 
	 * @param storagePath
	 *            The full path to this storage, can be <code>null</code>.
	 * @param element
	 *            The typed element for which we need to create a wrapper.
	 * @return The wrapped typed element.
	 * @throws IllegalArgumentException
	 *             If the given element does not implement {@link IStreamContentAccessor}.
	 */
	public static StreamAccessorStorage fromTypedElement(String storagePath, ITypedElement element)
			throws IllegalArgumentException {
		if (!(element instanceof IStreamContentAccessor)) {
			throw new IllegalArgumentException();
		}

		final String fullPath;
		if (storagePath != null) {
			fullPath = storagePath;
		} else {
			fullPath = findPath(element);
		}

		return new StreamAccessorStorage((IStreamContentAccessor)element, fullPath);
	}

	/**
	 * This will try to find a path for the given typed element. If that element can be adapted, it delegates
	 * to {@link #findPath(IAdaptable)}.
	 * 
	 * @param element
	 *            The element for which we need a path.
	 * @return A path for the given element.
	 */
	private static String findPath(ITypedElement element) {
		final String fullPath;
		final IFile file = findFile(element);
		if (file != null) {
			fullPath = file.getFullPath().toString();
		} else {
			final IFileRevision revision = findFileRevision(element);
			String tmp = null;
			if (revision != null) {
				final URI uri = revision.getURI();
				if (uri != null) {
					tmp = org.eclipse.emf.common.util.URI.decode(uri.toString());
				} else if (revision instanceof IAdaptable) {
					tmp = findPath((IAdaptable)revision);
				}
			}
			if (tmp != null) {
				fullPath = tmp;
			} else {
				// We can't do much here...
				fullPath = element.getName();
			}
		}
		return fullPath;
	}

	/**
	 * Get the commit id for the given element
	 * 
	 * @param element
	 *            The element for which we want the commit id
	 * @return the commit id
	 */
	public static IFileRevision findCommitId(ITypedElement element) {
		return findFileRevision(element);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see IStoragePathAdapterProvider#createStoragePathAdapter()
	 */
	public Adapter createStoragePathAdapter(String path, boolean isLocal) {
		IFileRevision findFileRevision = findFileRevision((ITypedElement)accessor);
		IFile file = findFile((ITypedElement)accessor);
		// The parameter isLocal is overwritten because more informations are available here to determine
		// whether the file is local or remote
		boolean local = file != null;

		if (!isLocal && findFileRevision != null) {
			return new StoragePathAdapter(path, local, findFileRevision.getContentIdentifier(),
					findFileRevision.getAuthor());
		} else {
			return new StoragePathAdapter(path, local);
		}
	}

	/**
	 * If the {@code adaptable} can be adapted to an {@link IResourceVariant}, we'll try to retrieve the
	 * resource's path. It will use {@link IStoragePathProvider}s, if any are registered. May return null
	 * 
	 * @param adaptable
	 *            The {@link IAdaptable} for which we need a path
	 * @return A path for the given element.
	 */
	private static String findPath(IAdaptable adaptable) {
		String result = null;

		final IResourceVariant variant = (IResourceVariant)adaptable.getAdapter(IResourceVariant.class);

		if (variant != null) {
			try {
				final IStorage storage = variant.getStorage(new NullProgressMonitor());
				if (storage != null) {
					final Object adapter = Platform.getAdapterManager().loadAdapter(storage,
							IStoragePathProvider.class.getName());
					if (adapter instanceof IStoragePathProvider) {
						final IPath fixedPath = ((IStoragePathProvider)adapter).computeFixedPath(storage);
						result = fixedPath.toString();
					} else if (storage instanceof IFile) {
						result = storage.getFullPath().toString();
					}
				} else if (variant instanceof CachedResourceVariant) {
					result = ((CachedResourceVariant)variant).getDisplayPath().toString();
				}
			} catch (TeamException e) {
				// Swallow, this was a best effort...
			}
		}
		return result;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
	 */
	// suppressing since overriding.
	@SuppressWarnings({"rawtypes", "unchecked" })
	public Object getAdapter(Class adapter) {
		Object adapted = null;
		if (adapter.isInstance(this)) {
			adapted = this;
		} else if (adapter == IStreamContentAccessor.class) {
			adapted = accessor;
		} else if (accessor instanceof ITypedElement) {
			if (adapter == ITypedElement.class) {
				adapted = accessor;
			} else if (adapter.isAssignableFrom(IFile.class)) {
				adapted = findFile((ITypedElement)accessor);
			}
		}
		return adapted;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.core.resources.IStorage#getContents()
	 */
	public InputStream getContents() throws CoreException {
		return accessor.getContents();
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.core.resources.IStorage#getFullPath()
	 */
	public IPath getFullPath() {
		return new Path(fullPath);
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.core.resources.IStorage#getName()
	 */
	public String getName() {
		if (accessor instanceof ITypedElement) {
			return ((ITypedElement)accessor).getName();
		}
		return getFullPath().lastSegment();
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.core.resources.IStorage#isReadOnly()
	 */
	public boolean isReadOnly() {
		if (accessor instanceof ITypedElement) {
			final IFile file = findFile((ITypedElement)accessor);
			if (file != null) {
				return file.isReadOnly();
			}
		}
		final File file = getFullPath().toFile();
		return !file.exists() || !file.canWrite();
	}

	/**
	 * Try and determine the file revision of the given element.
	 * 
	 * @param element
	 *            The element for which we need an {@link IFileRevision}.
	 * @return The file revision of the given element if we could find one, <code>null</code> otherwise.
	 */
	private static IFileRevision findFileRevision(ITypedElement element) {
		if (element == null) {
			return null;
		}

		// Can we adapt it directly?
		IFileRevision revision = adaptAs(element, IFileRevision.class);
		if (revision == null) {
			// Quite the workaround... but CVS does not offer us any other way.
			// These few lines of code is what make us depend on org.eclipse.ui... Can we find another way?
			final ISharedDocumentAdapter documentAdapter = adaptAs(element, ISharedDocumentAdapter.class);
			if (documentAdapter != null) {
				final IEditorInput editorInput = documentAdapter.getDocumentKey(element);
				if (editorInput != null) {
					revision = adaptAs(editorInput, IFileRevision.class);
				}
			}
		}

		if (revision == null) {
			// Couldn't do it the API way ...
			// At the time of writing, this was the case with EGit
			try {
				final Method method = element.getClass().getMethod("getFileRevision"); //$NON-NLS-1$
				final Object value = method.invoke(element);
				if (value instanceof IFileRevision) {
					revision = (IFileRevision)value;
				}
			} catch (NoSuchMethodException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException e) {
				// Ignore exceptions
			}
		}

		return revision;
	}
}