git2wrap

0 #include "git2wrap/tree.hpp"

1

2 #include "git2wrap/error.hpp"

3 #include "git2wrap/object.hpp"

4 #include "git2wrap/types.hpp"

5

6 namespace git2wrap

7 {

8

9 tree::tree(git_tree* tre, repositoryPtr repo)

10 : m_tree(tre, git_tree_free)

11 , m_repo(std::move(repo))

12 {

13 }

14

15 tree tree::dup() const

16 {

17 git_tree* tre = nullptr;

18 git_tree_dup(&tre, m_tree.get());

19 return {tre, m_repo};

20 }

21

22 oid tree::get_id() const

23 {

24 return oid(git_tree_id(m_tree.get()));

25 }

26

27 repositoryPtr tree::get_owner() const

28 {

29 return m_repo;

30 }

31

32 size_t tree::get_entrycount() const

33 {

34 return git_tree_entrycount(m_tree.get());

35 }

36

37 tree_entry tree::get_entry(const char* name) const

38 {

39 return {git_tree_entry_byname(m_tree.get(), name), m_repo};

40 }

41

42 tree_entry tree::get_entry(size_t idx) const

43 {

44 return {git_tree_entry_byindex(m_tree.get(), idx), m_repo};

45 }

46

47 tree_entry tree::get_entry(const oid& objid) const

48 {

49 return {git_tree_entry_byid(m_tree.get(), objid.ptr()), m_repo};

50 }

51

52 tree_entry tree::get_entry_path(const char* path) const

53 {

54 git_tree_entry* entry = nullptr;

55

56 const auto err =

57 error_code_t(git_tree_entry_bypath(&entry, m_tree.get(), path));

58

59 if (err == error_code_t::ok) {

60 return {entry, m_repo};

61 }

62

63 if (err == error_code_t::enotfound) {

64 throw error<error_code_t::enotfound>();

65 }

66

67 // should not happen

68 throw error<error_code_t::error>();

69 }

70

71 tree_entry::tree_entry(const git_tree_entry* entry, repositoryPtr repo)

72 : m_entry(const_cast<git_tree_entry*>(entry), empty_lambda) // NOLINT

73 , m_repo(std::move(repo))

74 {

75 }

76

77 tree_entry::tree_entry(git_tree_entry* entry, repositoryPtr repo)

78 : m_entry(entry, git_tree_entry_free)

79 , m_repo(std::move(repo))

80 {

81 }

82

83 tree_entry tree_entry::dup() const

84 {

85 git_tree_entry* entry = nullptr;

86

87 if (git_tree_entry_dup(&entry, m_entry.get()) != 0) {

88 throw error<error_code_t::error>();

89 }

90

91 return {entry, m_repo};

92 }

93

94 object tree_entry::to_object() const

95 {

96 git_object* obj = nullptr;

97

98 if (git_tree_entry_to_object(&obj, m_repo.get(), m_entry.get()) != 0) {

99 throw error<error_code_t::error>();

100 }

101

102 return {obj, m_repo};

103 }

104

105 tree tree_entry::to_tree() const

106 {

107 git_object* obj = nullptr;

108

109 if (git_tree_entry_to_object(&obj, m_repo.get(), m_entry.get()) != 0) {

110 throw error<error_code_t::error>();

111 }

112

113 return {reinterpret_cast<git_tree*>(obj), m_repo}; // NOLINT

114 }

115

116 const char* tree_entry::get_name() const

117 {

118 return git_tree_entry_name(m_entry.get());

119 }

120

121 oid tree_entry::get_id() const

122 {

123 return oid(git_tree_entry_id(m_entry.get()));

124 }

125

126 repositoryPtr tree_entry::get_owner() const

127 {

128 return m_repo;

129 }

130

131 object::object_t tree_entry::get_type() const

132 {

133 return object::object_t::get(git_tree_entry_type(m_entry.get()));

134 }

135

136 filemode_t tree_entry::get_filemode() const

137 {

138 return git_tree_entry_filemode(m_entry.get());

139 }

140

141 filemode_t tree_entry::get_filemode_raw() const

142 {

143 return git_tree_entry_filemode_raw(m_entry.get());

144 }

145

146 auto tree_entry::operator<=>(const tree_entry& rhs)

147 {

148 return git_tree_entry_cmp(m_entry.get(), rhs.m_entry.get());

149 }

150

151 } // namespace git2wrap