/*******************************************************************************
* 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;
}
}