src/TortoiseProc/lanes.h

   1 /*
   2         Author: Marco Costalba (C) 2005-2007
   3         Author: TortoiseGit (C) 2008-2013, 2017
   4
   5         Copyright: See COPYING file that comes with this distribution
   6
   7 */
   8 #ifndef LANES_H
   9 #define LANES_H
  10
  11 #include "githash.h"
  12
  13 #define QVector std::vector
  14
  15 typedef std::vector<CGitHash> CGitHashList ;
  16
  17 class Lanes {
  18 public:
  19         // graph elements
  20         enum LaneType {
  21                 EMPTY,
  22                 ACTIVE,
  23                 NOT_ACTIVE,
  24                 MERGE_FORK,
  25                 MERGE_FORK_R,
  26                 MERGE_FORK_L,
  27                 MERGE_FORK_L_INITIAL,
  28                 JOIN,
  29                 JOIN_R,
  30                 JOIN_L,
  31                 HEAD,
  32                 HEAD_R,
  33                 HEAD_L,
  34                 TAIL,
  35                 TAIL_R,
  36                 TAIL_L,
  37                 CROSS,
  38                 CROSS_EMPTY,
  39                 INITIAL,
  40                 BRANCH,
  41                 UNAPPLIED,
  42                 APPLIED,
  43                 BOUNDARY,
  44                 BOUNDARY_C, // corresponds to MERGE_FORK
  45                 BOUNDARY_R, // corresponds to MERGE_FORK_R
  46                 BOUNDARY_L, // corresponds to MERGE_FORK_L
  47
  48                 LANE_TYPES_NUM,
  49                 COLORS_NUM=8
  50         };
  51
  52         // graph helpers
  53         static inline bool isHead(int x) { return (x == HEAD || x == HEAD_R || x == HEAD_L); }
  54         static inline bool isTail(int x) { return (x == TAIL || x == TAIL_R || x == TAIL_L); }
  55         static inline bool isJoin(int x) { return (x == JOIN || x == JOIN_R || x == JOIN_L); }
  56         static inline bool isFreeLane(int x) { return (x == NOT_ACTIVE || x == CROSS || isJoin(x)); }
  57         static inline bool isBoundary(int x) { return (x == BOUNDARY || x == BOUNDARY_C ||
  58                                                 x == BOUNDARY_R || x == BOUNDARY_L); }
  59         static inline bool isMerge(int x) { return (x == MERGE_FORK || x == MERGE_FORK_R ||
  60                                              x == MERGE_FORK_L || isBoundary(x)); }
  61         static inline bool isActive(int x) { return (x == ACTIVE || x == INITIAL || x == BRANCH ||
  62                                               isMerge(x)); }
  63
  64         Lanes() // init() will setup us later, when data is available
  65                 : activeLane(0)
  66                 , boundary(false)
  67                 , NODE(0)
  68                 , NODE_L(0)
  69                 , NODE_R(0)
  70         {}
  71         bool isEmpty() { return typeVec.empty(); }
  72         void init(const CGitHash& expectedSha);
  73         void clear();
  74         bool isFork(const CGitHash& sha, bool& isDiscontinuity);
  75         void setBoundary(bool isBoundary, bool isInitial);
  76         void setFork(const CGitHash& sha);
  77         void setMerge(const CGitHashList& parents);
  78         void setInitial();
  79         void setApplied();
  80         void changeActiveLane(const CGitHash& sha);
  81         void afterMerge();
  82         void afterFork();
  83         bool isBranch();
  84         void afterBranch();
  85         void afterApplied();
  86         void nextParent(const CGitHash& sha);
  87         void getLanes(QVector<int> &ln) { ln = typeVec; } // O(1) vector is implicitly shared
  88
  89 private:
  90         int findNextSha(const CGitHash& next, int pos);
  91         int findType(int type, int pos);
  92         int add(int type, const CGitHash& next, int pos, bool& wasEmptyCross);
  93
  94         int activeLane;
  95         QVector<int> typeVec;
  96         QVector<CGitHash> nextShaVec;
  97         bool boundary;
  98         int NODE, NODE_L, NODE_R;
  99 };
 100
 101 #endif