org.eclipse.jgit.iplog/src/org/eclipse/jgit/iplog/Committer.java

   1 /*
   2  * Copyright (C) 2010, Google Inc.
   3  * and other copyright owners as documented in the project's IP log.
   4  *
   5  * This program and the accompanying materials are made available
   6  * under the terms of the Eclipse Distribution License v1.0 which
   7  * accompanies this distribution, is reproduced below, and is
   8  * available at http://www.eclipse.org/org/documents/edl-v10.php
   9  *
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or
  13  * without modification, are permitted provided that the following
  14  * conditions are met:
  15  *
  16  * - Redistributions of source code must retain the above copyright
  17  *   notice, this list of conditions and the following disclaimer.
  18  *
  19  * - Redistributions in binary form must reproduce the above
  20  *   copyright notice, this list of conditions and the following
  21  *   disclaimer in the documentation and/or other materials provided
  22  *   with the distribution.
  23  *
  24  * - Neither the name of the Eclipse Foundation, Inc. nor the
  25  *   names of its contributors may be used to endorse or promote
  26  *   products derived from this software without specific prior
  27  *   written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  30  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  31  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  32  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  33  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  34  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  38  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  41  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42  */
  43
  44 package org.eclipse.jgit.iplog;
  45
  46 import java.util.ArrayList;
  47 import java.util.Collections;
  48 import java.util.Comparator;
  49 import java.util.Date;
  50 import java.util.HashSet;
  51 import java.util.List;
  52 import java.util.Set;
  53
  54 /** A project committer. */
  55 class Committer {
  56         /** Sorts committers by their name first name, then last name. */
  57         static final Comparator<Committer> COMPARATOR = new Comparator<Committer>() {
  58                 public int compare(Committer a, Committer b) {
  59                         int cmp = a.firstName.compareTo(b.firstName);
  60                         if (cmp == 0)
  61                                 cmp = a.lastName.compareTo(b.lastName);
  62                         return cmp;
  63                 }
  64         };
  65
  66         private final String id;
  67
  68         private String firstName;
  69
  70         private String lastName;
  71
  72         private String affiliation;
  73
  74         private boolean hasCommits;
  75
  76         private String comments;
  77
  78         private final Set<String> emailAddresses = new HashSet<String>();
  79
  80         private final List<ActiveRange> active = new ArrayList<ActiveRange>(2);
  81
  82         /**
  83          * @param id
  84          *            unique identity of the committer
  85          */
  86         Committer(String id) {
  87                 this.id = id;
  88         }
  89
  90         /** @return unique identity of this committer in the foundation database. */
  91         String getID() {
  92                 return id;
  93         }
  94
  95         /** @return first name of the committer; their given name. */
  96         String getFirstName() {
  97                 return firstName;
  98         }
  99
 100         void setFirstName(String firstName) {
 101                 this.firstName = firstName;
 102         }
 103
 104         /** @return last name of the committer; their surname or family name. */
 105         String getLastName() {
 106                 return lastName;
 107         }
 108
 109         void setLastName(String lastName) {
 110                 this.lastName = lastName;
 111         }
 112
 113         /** @return the organization the committer is affiliated with. */
 114         String getAffiliation() {
 115                 return affiliation;
 116         }
 117
 118         void setAffiliation(String affiliation) {
 119                 this.affiliation = affiliation;
 120         }
 121
 122         /** @return true if this committer is still an active member of the project. */
 123         boolean isActive() {
 124                 if (active.isEmpty())
 125                         return false;
 126                 ActiveRange last = active.get(active.size() - 1);
 127                 return last.end == null;
 128         }
 129
 130         /** @return true if this committer has commits in the project. */
 131         boolean hasCommits() {
 132                 return hasCommits;
 133         }
 134
 135         void setHasCommits(boolean hasCommits) {
 136                 this.hasCommits = hasCommits;
 137         }
 138
 139         /** @return any additional comments about this committer. */
 140         String getComments() {
 141                 return comments;
 142         }
 143
 144         void setComments(String comments) {
 145                 this.comments = comments;
 146         }
 147
 148         void addEmailAddress(String email) {
 149                 emailAddresses.add(email);
 150         }
 151
 152         void addActiveRange(ActiveRange r) {
 153                 active.add(r);
 154                 Collections.sort(active, new Comparator<ActiveRange>() {
 155                         public int compare(ActiveRange a, ActiveRange b) {
 156                                 return a.begin.compareTo(b.begin);
 157                         }
 158                 });
 159         }
 160
 161         /**
 162          * @param when
 163          * @return true if the event occurred while an active committer.
 164          */
 165         boolean inRange(Date when) {
 166                 for (ActiveRange ar : active) {
 167                         if (ar.contains(when))
 168                                 return true;
 169                 }
 170                 return false;
 171         }
 172
 173         @Override
 174         public String toString() {
 175                 return "Committer " + getFirstName() + " " + getLastName();
 176         }
 177
 178         /** Date period during which the committer was active. */
 179         static class ActiveRange {
 180                 private final Date begin;
 181
 182                 private final Date end;
 183
 184                 /**
 185                  * @param begin
 186                  * @param end
 187                  */
 188                 ActiveRange(Date begin, Date end) {
 189                         this.begin = begin;
 190                         this.end = end;
 191                 }
 192
 193                 /**
 194                  * @param when
 195                  * @return true if {@code when} is within this date span.
 196                  */
 197                 boolean contains(Date when) {
 198                         if (when.compareTo(begin) < 0)
 199                                 return false;
 200                         if (end == null)
 201                                 return true;
 202                         return when.compareTo(end) < 0;
 203                 }
 204         }
 205 }