Andrew's git - gitweb.git/blob

   1#ifndef WORKTREE_H
   2#define WORKTREE_H
   3
   4#include "cache.h"
   5#include "refs.h"
   6
   7struct strbuf;
   8
   9struct 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 */
  33struct worktree **get_worktrees(unsigned flags);
  34
  35/*
  36 * Returns 1 if linked worktrees exist, 0 otherwise.
  37 */
  38int 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 */
  44const 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 */
  50struct 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 */
  57int 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 */
  63const 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 */
  71int 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 */
  78void update_worktree_location(struct worktree *wt,
  79                              const char *path_);
  80
  81/*
  82 * Free up the memory for worktree(s)
  83 */
  84void 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 */
  91const 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 */
  98int other_head_refs(each_ref_fn fn, void *cb_data);
  99
 100int is_worktree_being_rebased(const struct worktree *wt, const char *target);
 101int 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 */
 107const 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 */
 118int 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 */
 124void 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 */
 132const char *worktree_ref(const struct worktree *wt,
 133                         const char *refname);
 134
 135#endif