worktree.h

   1 #ifndef WORKTREE_H
   2 #define WORKTREE_H
   3
   4 #include "cache.h"
   5 #include "refs.h"
   6
   7 struct strbuf;
   8
   9 struct worktree {
  10         char *path;
  11         char *id;
  12         char *head_ref;         /* NULL if HEAD is broken or detached */
  13         char *lock_reason;      /* private - use worktree_lock_reason */
  14         struct object_id head_oid;
  15         int is_detached;
  16         int is_bare;
  17         int is_current;
  18         int lock_reason_valid; /* private */
  19 };
  20
  21 /* Functions for acting on the information about worktrees. */
  22
  23 #define GWT_SORT_LINKED (1 << 0) /* keeps linked worktrees sorted */
  24
  25 /*
  26  * Get the worktrees.  The primary worktree will always be the first returned,
  27  * and linked worktrees will be pointed to by 'next' in each subsequent
  28  * worktree.  No specific ordering is done on the linked worktrees.
  29  *
  30  * The caller is responsible for freeing the memory from the returned
  31  * worktree(s).
  32  */
  33 struct worktree **get_worktrees(unsigned flags);
  34
  35 /*
  36  * Returns 1 if linked worktrees exist, 0 otherwise.
  37  */
  38 int submodule_uses_worktrees(const char *path);
  39
  40 /*
  41  * Return git dir of the worktree. Note that the path may be relative.
  42  * If wt is NULL, git dir of current worktree is returned.
  43  */
  44 const char *get_worktree_git_dir(const struct worktree *wt);
  45
  46 /*
  47  * Search for the worktree identified unambiguously by `arg` -- typically
  48  * supplied by the user via the command-line -- which may be a pathname or some
  49  * shorthand uniquely identifying a worktree, thus making it convenient for the
  50  * user to specify a worktree with minimal typing. For instance, if the last
  51  * component (say, "foo") of a worktree's pathname is unique among worktrees
  52  * (say, "work/foo" and "work/bar"), it can be used to identify the worktree
  53  * unambiguously.
  54  *
  55  * `prefix` should be the `prefix` handed to top-level Git commands along with
  56  * `argc` and `argv`.
  57  *
  58  * Return the worktree identified by `arg`, or NULL if not found.
  59  */
  60 struct worktree *find_worktree(struct worktree **list,
  61                                const char *prefix,
  62                                const char *arg);
  63
  64 /*
  65  * Return the worktree corresponding to `path`, or NULL if no such worktree
  66  * exists.
  67  */
  68 struct worktree *find_worktree_by_path(struct worktree **, const char *path);
  69
  70 /*
  71  * Return true if the given worktree is the main one.
  72  */
  73 int is_main_worktree(const struct worktree *wt);
  74
  75 /*
  76  * Return the reason string if the given worktree is locked or NULL
  77  * otherwise.
  78  */
  79 const char *worktree_lock_reason(struct worktree *wt);
  80
  81 #define WT_VALIDATE_WORKTREE_MISSING_OK (1 << 0)
  82
  83 /*
  84  * Return zero if the worktree is in good condition. Error message is
  85  * returned if "errmsg" is not NULL.
  86  */
  87 int validate_worktree(const struct worktree *wt,
  88                       struct strbuf *errmsg,
  89                       unsigned flags);
  90
  91 /*
  92  * Update worktrees/xxx/gitdir with the new path.
  93  */
  94 void update_worktree_location(struct worktree *wt,
  95                               const char *path_);
  96
  97 /*
  98  * Free up the memory for worktree(s)
  99  */
 100 void free_worktrees(struct worktree **);
 101
 102 /*
 103  * Check if a per-worktree symref points to a ref in the main worktree
 104  * or any linked worktree, and return the worktree that holds the ref,
 105  * or NULL otherwise. The result may be destroyed by the next call.
 106  */
 107 const struct worktree *find_shared_symref(const char *symref,
 108                                           const char *target);
 109
 110 /*
 111  * Similar to head_ref() for all HEADs _except_ one from the current
 112  * worktree, which is covered by head_ref().
 113  */
 114 int other_head_refs(each_ref_fn fn, void *cb_data);
 115
 116 int is_worktree_being_rebased(const struct worktree *wt, const char *target);
 117 int is_worktree_being_bisected(const struct worktree *wt, const char *target);
 118
 119 /*
 120  * Similar to git_path() but can produce paths for a specified
 121  * worktree instead of current one
 122  */
 123 const char *worktree_git_path(const struct worktree *wt,
 124                               const char *fmt, ...)
 125         __attribute__((format (printf, 2, 3)));
 126
 127 /*
 128  * Parse a worktree ref (i.e. with prefix main-worktree/ or
 129  * worktrees/) and return the position of the worktree's name and
 130  * length (or NULL and zero if it's main worktree), and ref.
 131  *
 132  * All name, name_length and ref arguments could be NULL.
 133  */
 134 int parse_worktree_ref(const char *worktree_ref, const char **name,
 135                        int *name_length, const char **ref);
 136
 137 /*
 138  * Return a refname suitable for access from the current ref store.
 139  */
 140 void strbuf_worktree_ref(const struct worktree *wt,
 141                          struct strbuf *sb,
 142                          const char *refname);
 143
 144 /*
 145  * Return a refname suitable for access from the current ref
 146  * store. The result will be destroyed at the next call.
 147  */
 148 const char *worktree_ref(const struct worktree *wt,
 149                          const char *refname);
 150
 151 #endif