FilesExpand file tree

master

/

worktree.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

173 lines (158 loc) · 5.05 KB

master

/

worktree.h

Copy path

Top

File metadata and controls

• Code
• Blame

173 lines (158 loc) · 5.05 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

/*

* Copyright (C) the libgit2 contributors. All rights reserved.

*

* This file is part of libgit2, distributed under the GNU GPL v2 with

* a Linking Exception. For full terms see the included COPYING file.

*/

#ifndef INCLUDE_git_worktree_h__

#define INCLUDE_git_worktree_h__

#include "common.h"

#include "buffer.h"

#include "types.h"

#include "strarray.h"

/**

* @file git2/worktrees.h

* @brief Git worktree related functions

* @defgroup git_commit Git worktree related functions

* @ingroup Git

* @{

*/

GIT_BEGIN_DECL

/**

* List names of linked working trees

*

* The returned list should be released with `git_strarray_free`

* when no longer needed.

*

* @param out pointer to the array of working tree names

* @param repo the repo to use when listing working trees

* @return 0 or an error code

*/

GIT_EXTERN(int) git_worktree_list(git_strarray *out, git_repository *repo);

/**

* Lookup a working tree by its name for a given repository

*

* @param out Output pointer to looked up worktree or `NULL`

* @param repo The repository containing worktrees

* @param name Name of the working tree to look up

* @return 0 or an error code

*/

GIT_EXTERN(int) git_worktree_lookup(git_worktree **out, git_repository *repo, const char *name);

/**

* Open a worktree of a given repository

*

* If a repository is not the main tree but a worktree, this

* function will look up the worktree inside the parent

* repository and create a new `git_worktree` structure.

*

* @param out Out-pointer for the newly allocated worktree

* @param repo Repository to look up worktree for

*/

GIT_EXTERN(int) git_worktree_open_from_repository(git_worktree **out, git_repository *repo);

/**

* Free a previously allocated worktree

*

* @param wt worktree handle to close. If NULL nothing occurs.

*/

GIT_EXTERN(void) git_worktree_free(git_worktree *wt);

/**

* Check if worktree is valid

*

* A valid worktree requires both the git data structures inside

* the linked parent repository and the linked working copy to be

* present.

*

* @param wt Worktree to check

* @return 0 when worktree is valid, error-code otherwise

*/

GIT_EXTERN(int) git_worktree_validate(const git_worktree *wt);

/**

* Add a new working tree

*

* Add a new working tree for the repository, that is create the

* required data structures inside the repository and check out

* the current HEAD at `path`

*

* @param out Output pointer containing new working tree

* @param repo Repository to create working tree for

* @param name Name of the working tree

* @param path Path to create working tree at

* @return 0 or an error code

*/

GIT_EXTERN(int) git_worktree_add(git_worktree **out, git_repository *repo, const char *name, const char *path);

/**

* Lock worktree if not already locked

*

* Lock a worktree, optionally specifying a reason why the linked

* working tree is being locked.

*

* @param wt Worktree to lock

* @param reason Reason why the working tree is being locked

* @return 0 on success, non-zero otherwise

*/

GIT_EXTERN(int) git_worktree_lock(git_worktree *wt, char *reason);

/**

* Unlock a locked worktree

*

* @param wt Worktree to unlock

* @return 0 on success, 1 if worktree was not locked, error-code

* otherwise

*/

GIT_EXTERN(int) git_worktree_unlock(git_worktree *wt);

/**

* Check if worktree is locked

*

* A worktree may be locked if the linked working tree is stored

* on a portable device which is not available.

*

* @param reason Buffer to store reason in. If NULL no reason is stored.

* @param wt Worktree to check

* @return 0 when the working tree not locked, a value greater

* than zero if it is locked, less than zero if there was an

* error

*/

GIT_EXTERN(int) git_worktree_is_locked(git_buf *reason, const git_worktree *wt);

/**

* Flags which can be passed to git_worktree_prune to alter its

* behavior.

*/

typedef enum {

/* Prune working tree even if working tree is valid */

GIT_WORKTREE_PRUNE_VALID = 1u << 0,

/* Prune working tree even if it is locked */

GIT_WORKTREE_PRUNE_LOCKED = 1u << 1,

/* Prune checked out working tree */

GIT_WORKTREE_PRUNE_WORKING_TREE = 1u << 2,

} git_worktree_prune_t;

/**

* Is the worktree prunable with the given set of flags?

*

* A worktree is not prunable in the following scenarios:

*

* - the worktree is linking to a valid on-disk worktree. The

* GIT_WORKTREE_PRUNE_VALID flag will cause this check to be

* ignored.

* - the worktree is not valid but locked. The

* GIT_WORKRTEE_PRUNE_LOCKED flag will cause this check to be

* ignored.

*

* If the worktree is not valid and not locked or if the above

* flags have been passed in, this function will return a

* positive value.

*/

GIT_EXTERN(int) git_worktree_is_prunable(git_worktree *wt, unsigned flags);

/**

* Prune working tree

*

* Prune the working tree, that is remove the git data

* structures on disk. The repository will only be pruned of

* `git_worktree_is_prunable` succeeds.

*

* @param wt Worktree to prune

* @param flags git_worktree_prune_t flags

* @return 0 or an error code

*/

GIT_EXTERN(int) git_worktree_prune(git_worktree *wt, unsigned flags);

/** @} */

GIT_END_DECL

#endif