Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.egit/src/org/eclipse/emf/compare/egit/internal/merge/DirCacheResourceVariantTreeProvider.java

1 /*******************************************************************************

5 * are made available under the terms of the Eclipse Public License v1.0

6 * which accompanies this distribution, and is available at

7 * http://www.eclipse.org/legal/epl-v10.html

8 *******************************************************************************/

package org.eclipse.emf.compare.egit.internal.merge;

11 //CHECKSTYLE:OFF

12 import java.io.IOException;

13 import java.util.LinkedHashSet;

14 import java.util.Set;

import org.eclipse.core.resources.IResource;

import org.eclipse.egit.core.internal.storage.IndexResourceVariant;

import org.eclipse.emf.compare.egit.internal.ModelEGitResourceUtil;

import org.eclipse.emf.compare.egit.internal.storage.GitLocalResourceVariant;

import org.eclipse.jgit.dircache.DirCache;

import org.eclipse.jgit.dircache.DirCacheEntry;

import org.eclipse.jgit.lib.FileMode;

import org.eclipse.jgit.lib.Repository;

import org.eclipse.team.core.variants.IResourceVariantTree;

26 /**

27 * This will populate its three {@link IResourceVariantTree} by looking up information within the repository's

28 * DirCache.

29 * <p>

30 * Files that are not located within the workspace will be ignored and thus will not be accessible through the

31 * trees created by this provider.

32 * </p>

33 *

34 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

35 */

36 public class DirCacheResourceVariantTreeProvider implements GitResourceVariantTreeProvider {

37 private final IResourceVariantTree baseTree;

39 private final IResourceVariantTree sourceTree;

41 private final IResourceVariantTree remoteTree;

43 private final Set<IResource> roots;

45 private final Set<IResource> knownResources;

47 /**

48 * Constructs the resource variant trees by iterating over the given repository's DirCache entries.

49 *

50 * @param repository

51 * The repository which DirCache info we need to cache as IResourceVariantTrees.

52 * @param useWorkspace

53 * Whether we should use local data instead of what's in the index for our side.

54 * @throws IOException

55 * if we somehow cannot read the DirCache.

56 */

        public DirCacheResourceVariantTreeProvider(Repository repository, boolean useWorkspace)

58 throws IOException {

                final DirCache cache = repository.readDirCache();

                final GitResourceVariantCache baseCache = new GitResourceVariantCache();

                final GitResourceVariantCache sourceCache = new GitResourceVariantCache();

                final GitResourceVariantCache remoteCache = new GitResourceVariantCache();

                for (int i = 0; i < cache.getEntryCount(); i++) {

                        final DirCacheEntry entry = cache.getEntry(i);

                        final IResource resource = ModelEGitResourceUtil.getResourceHandleForLocation(repository, entry

                                        .getPathString(), FileMode.fromBits(entry.getRawMode()) == FileMode.TREE);

68 // Resource variants only make sense for IResources. Do not consider

69 // files outside of the workspace or otherwise non accessible.

                        if (resource == null || resource.getProject() == null || !resource.getProject().isAccessible()) {

71 continue;

72 }

                        switch (entry.getStage()) {

74 case DirCacheEntry.STAGE_0:

75 if (useWorkspace) {

                                                sourceCache.setVariant(resource, new GitLocalResourceVariant(resource));

77 } else {

                                                sourceCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

79 }

                                        baseCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

                                        remoteCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

82 break;

83 case DirCacheEntry.STAGE_1:

                                        baseCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

85 break;

86 case DirCacheEntry.STAGE_2:

87 if (useWorkspace) {

                                                sourceCache.setVariant(resource, new GitLocalResourceVariant(resource));

89 } else {

                                                sourceCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

91 }

92 break;

93 case DirCacheEntry.STAGE_3:

                                        remoteCache.setVariant(resource, IndexResourceVariant.create(repository, entry));

95 break;

96 default:

                                        throw new IllegalStateException("Invalid stage: " + entry.getStage()); //$NON-NLS-1$

98 }

99 }

100

                baseTree = new GitCachedResourceVariantTree(baseCache);

                sourceTree = new GitCachedResourceVariantTree(sourceCache);

                remoteTree = new GitCachedResourceVariantTree(remoteCache);

104

105 roots = new LinkedHashSet<IResource>();

                roots.addAll(baseCache.getRoots());

                roots.addAll(sourceCache.getRoots());

                roots.addAll(remoteCache.getRoots());

109

110 knownResources = new LinkedHashSet<IResource>();

                knownResources.addAll(baseCache.getKnownResources());

                knownResources.addAll(sourceCache.getKnownResources());

                knownResources.addAll(remoteCache.getKnownResources());

114 }

115

116 public IResourceVariantTree getBaseTree() {

117 return baseTree;

118 }

119

120 public IResourceVariantTree getRemoteTree() {

121 return remoteTree;

122 }

123

124 public IResourceVariantTree getSourceTree() {

125 return sourceTree;

126 }

127

        public Set<IResource> getKnownResources() {

129 return knownResources;

130 }

131

        public Set<IResource> getRoots() {

133 return roots;

134 }

135 }

136 // CHECKSTYLE:ON