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 a worktree that can be unambiguously identified by
  48  * "arg". "prefix" must not be NULL.
  49  */
  50 struct worktree *find_worktree(struct worktree **list,
  51                                const char *prefix,
  52                                const char *arg);
  53
  54 /*
  55  * Return true if the given worktree is the main one.
  56  */
  57 int is_main_worktree(const struct worktree *wt);
  58
  59 /*
  60  * Return the reason string if the given worktree is locked or NULL
  61  * otherwise.
  62  */
  63 const char *worktree_lock_reason(struct worktree *wt);
  64
  65 #define WT_VALIDATE_WORKTREE_MISSING_OK (1 << 0)
  66
  67 /*
  68  * Return zero if the worktree is in good condition. Error message is
  69  * returned if "errmsg" is not NULL.
  70  */
  71 int validate_worktree(const struct worktree *wt,
  72                       struct strbuf *errmsg,
  73                       unsigned flags);
  74
  75 /*
  76  * Update worktrees/xxx/gitdir with the new path.
  77  */
  78 void update_worktree_location(struct worktree *wt,
  79                               const char *path_);
  80
  81 /*
  82  * Free up the memory for worktree(s)
  83  */
  84 void free_worktrees(struct worktree **);
  85
  86 /*
  87  * Check if a per-worktree symref points to a ref in the main worktree
  88  * or any linked worktree, and return the worktree that holds the ref,
  89  * or NULL otherwise. The result may be destroyed by the next call.
  90  */
  91 const struct worktree *find_shared_symref(const char *symref,
  92                                           const char *target);
  93
  94 /*
  95  * Similar to head_ref() for all HEADs _except_ one from the current
  96  * worktree, which is covered by head_ref().
  97  */
  98 int other_head_refs(each_ref_fn fn, void *cb_data);
  99
 100 int is_worktree_being_rebased(const struct worktree *wt, const char *target);
 101 int is_worktree_being_bisected(const struct worktree *wt, const char *target);
 102
 103 /*
 104  * Similar to git_path() but can produce paths for a specified
 105  * worktree instead of current one
 106  */
 107 const char *worktree_git_path(const struct worktree *wt,
 108                               const char *fmt, ...)
 109         __attribute__((format (printf, 2, 3)));
 110
 111 /*
 112  * Parse a worktree ref (i.e. with prefix main-worktree/ or
 113  * worktrees/) and return the position of the worktree's name and
 114  * length (or NULL and zero if it's main worktree), and ref.
 115  *
 116  * All name, name_length and ref arguments could be NULL.
 117  */
 118 int parse_worktree_ref(const char *worktree_ref, const char **name,
 119                        int *name_length, const char **ref);
 120
 121 /*
 122  * Return a refname suitable for access from the current ref store.
 123  */
 124 void strbuf_worktree_ref(const struct worktree *wt,
 125                          struct strbuf *sb,
 126                          const char *refname);
 127
 128 /*
 129  * Return a refname suitable for access from the current ref
 130  * store. The result will be destroyed at the next call.
 131  */
 132 const char *worktree_ref(const struct worktree *wt,
 133                          const char *refname);
 134
 135 #endif