org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/synchronize/model/GitModelRepository.java

   1 /*******************************************************************************
   2  * Copyright (C) 2010, 2013 Dariusz Luksza <dariusz@luksza.org> and others.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License 2.0
   6  * which accompanies this distribution, and is available at
   7  * https://www.eclipse.org/legal/epl-2.0/
   8  *
   9  * SPDX-License-Identifier: EPL-2.0
  10  *******************************************************************************/
  11 package org.eclipse.egit.ui.internal.synchronize.model;
  12
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.eclipse.compare.structuremergeviewer.Differencer;
  21 import org.eclipse.core.resources.IProject;
  22 import org.eclipse.core.runtime.IPath;
  23 import org.eclipse.core.runtime.Path;
  24 import org.eclipse.egit.core.synchronize.GitCommitsModelCache;
  25 import org.eclipse.egit.core.synchronize.GitCommitsModelCache.Change;
  26 import org.eclipse.egit.core.synchronize.GitCommitsModelCache.Commit;
  27 import org.eclipse.egit.core.synchronize.StagedChangeCache;
  28 import org.eclipse.egit.core.synchronize.WorkingTreeChangeCache;
  29 import org.eclipse.egit.core.synchronize.dto.GitSynchronizeData;
  30 import org.eclipse.egit.ui.Activator;
  31 import org.eclipse.jgit.lib.ObjectId;
  32 import org.eclipse.jgit.lib.Repository;
  33 import org.eclipse.jgit.revwalk.RevCommit;
  34 import org.eclipse.jgit.revwalk.RevObject;
  35 import org.eclipse.jgit.treewalk.filter.TreeFilter;
  36
  37 /**
  38  * Representation of Git repository in Git ChangeSet model.
  39  */
  40 public class GitModelRepository extends GitModelObjectContainer implements HasProjects {
  41
  42         private IPath location;
  43
  44         private final GitSynchronizeData gsd;
  45
  46         private GitModelObject[] children;
  47
  48         /**
  49          * @param gsd
  50          *            synchronization data
  51          * @throws IOException
  52          */
  53         public GitModelRepository(GitSynchronizeData gsd) throws IOException {
  54                 super(null);
  55                 this.gsd = gsd;
  56         }
  57
  58         @Override
  59         public GitModelObject[] getChildren() {
  60                 List<GitModelObjectContainer> result = new ArrayList<>();
  61                 Repository repo = gsd.getRepository();
  62                 RevCommit srcRevCommit = gsd.getSrcRevCommit();
  63                 RevCommit dstRevCommit = gsd.getDstRevCommit();
  64                 TreeFilter pathFilter = gsd.getPathFilter();
  65                 List<Commit> commitCache;
  66                 if (srcRevCommit != null && dstRevCommit != null)
  67                         try {
  68                                 commitCache = GitCommitsModelCache.build(repo, srcRevCommit,
  69                                                 dstRevCommit, pathFilter);
  70                         } catch (IOException e) {
  71                                 Activator.logError(e.getMessage(), e);
  72                                 commitCache = null;
  73                         }
  74                 else
  75                         commitCache = null;
  76                 if (commitCache != null && !commitCache.isEmpty())
  77                         result.addAll(getListOfCommit(commitCache));
  78
  79                 result.addAll(getWorkingChanges());
  80                 disposeOldChildren();
  81                 children = result.toArray(new GitModelObjectContainer[0]);
  82
  83                 return children;
  84         }
  85
  86         @Override
  87         public String getName() {
  88                 return gsd.getRepository().getWorkTree().toString();
  89         }
  90
  91         @Override
  92         public IProject[] getProjects() {
  93                 return gsd.getProjects().toArray(new IProject[gsd.getProjects().size()]);
  94         }
  95
  96         @Override
  97         public int repositoryHashCode() {
  98                 return hashCode();
  99         }
 100
 101         /**
 102          * @return source {@link RevObject}
 103          */
 104         public ObjectId getSrcRev() {
 105                 return gsd.getSrcRevCommit();
 106         }
 107
 108         @Override
 109         public IPath getLocation() {
 110                 if (location == null)
 111                         location = new Path(gsd.getRepository().getWorkTree().toString());
 112
 113                 return location;
 114         }
 115
 116         @Override
 117         public int getKind() {
 118                 return Differencer.CHANGE;
 119         }
 120
 121         @Override
 122         public void dispose() {
 123                 disposeOldChildren();
 124         }
 125
 126         @Override
 127         public boolean equals(Object obj) {
 128                 if (obj == this)
 129                         return true;
 130
 131                 if (obj instanceof GitModelRepository) {
 132                         File objWorkTree = ((GitModelRepository) obj).gsd.getRepository()
 133                                         .getWorkTree();
 134                         return objWorkTree.equals(gsd.getRepository().getWorkTree());
 135                 }
 136
 137                 return false;
 138         }
 139
 140         @Override
 141         public int hashCode() {
 142                 return gsd.getRepository().getWorkTree().hashCode();
 143         }
 144
 145         @Override
 146         public String toString() {
 147                 return "ModelRepository[" + gsd.getRepository().getWorkTree() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
 148         }
 149
 150         private List<GitModelObjectContainer> getListOfCommit(List<Commit> commitCache) {
 151                 Repository repo = gsd.getRepository();
 152                 Set<IProject> projectsSet = gsd.getProjects();
 153                 IProject[] projects = projectsSet.toArray(new IProject[0]);
 154                 List<GitModelObjectContainer> result = new ArrayList<>();
 155
 156                 for (Commit commit : commitCache)
 157                         result.add(new GitModelCommit(this, repo, commit, projects));
 158
 159                 return result;
 160         }
 161
 162         private List<GitModelObjectContainer> getWorkingChanges() {
 163                 List<GitModelObjectContainer> result = new ArrayList<>();
 164                 if (gsd.shouldIncludeLocal()) {
 165                         Repository repo = gsd.getRepository();
 166                         Map<String, Change> stagedChanges = StagedChangeCache.build(repo);
 167                         GitModelCache gitCache = new GitModelCache(this, repo,
 168                                         stagedChanges);
 169                         int gitCacheLen = gitCache.getChildren().length;
 170
 171                         Map<String, Change> workingChanges = WorkingTreeChangeCache.build(repo);
 172                         GitModelWorkingTree gitWorkingTree = new GitModelWorkingTree(this,
 173                                         repo, workingChanges);
 174                         int gitWorkingTreeLen = gitWorkingTree.getChildren().length;
 175
 176                         if (gitCacheLen > 0 || gitWorkingTreeLen > 0) {
 177                                 result.add(gitCache);
 178                                 result.add(gitWorkingTree);
 179                         }
 180                 }
 181
 182                 return result;
 183         }
 184
 185         /**
 186          * @return repository
 187          */
 188         public Repository getRepository() {
 189                 return gsd.getRepository();
 190         }
 191
 192         private void disposeOldChildren() {
 193                 if (children == null)
 194                         return;
 195                 for (GitModelObject child : children)
 196                         child.dispose();
 197
 198         }
 199
 200 }