git2wrap

C++20 wrapper for libgit2
git clone git://git.dimitrijedobrota.com/git2wrap.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
commit53dd34646d95815b781900a3ee6ba6bffeb723b7
parenteb6f4f335bd61d025be76cfef7febe34f655d0f8
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateSun, 5 Jan 2025 21:25:04 +0100

Repository branch iterator * Errors now contain filename and line number

Diffstat:
MCMakeLists.txt|++-
Minclude/git2wrap/git2wrap.hpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
Asource/branch.cpp|++++++++++++++++++++++++++++++++++++++++++++++++
Msource/libgit2.cpp|+-
Msource/repository.cpp|++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----

5 files changed, 178 insertions(+), 9 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake)

project(
git2wrap
VERSION 0.1.1
VERSION 0.1.2
DESCRIPTION "C++ 20 wrapper for libgit2"
HOMEPAGE_URL "https://git.dimitrijedobrota.com/git2wrap.git"
LANGUAGES CXX

@@ -19,6 +19,7 @@ add_library(

git2wrap_git2wrap
source/libgit2.cpp
source/repository.cpp
source/branch.cpp
)
add_library(git2wrap::git2wrap ALIAS git2wrap_git2wrap)

diff --git a/include/git2wrap/git2wrap.hpp b/include/git2wrap/git2wrap.hpp

@@ -13,21 +13,30 @@ namespace git2wrap

class GIT2WRAP_EXPORT error : public std::exception
{
public:
explicit error(int err, const git_error* git_err)
explicit error(int err,
const git_error* git_err,
const char* file,
unsigned line)
: m_error(err)
, m_klass(git_err->klass)
, m_message(git_err->message)
, m_file(file)
, m_line(line)
{
}
const char* get_message() const { return m_message.c_str(); }
int get_klass() const { return m_klass; }
int get_error() const { return m_error; }
unsigned get_line() const { return m_line; }
const char* get_file() const { return m_file; }
const char* get_message() const { return m_message.c_str(); }
private:
int m_error;
int m_klass;
std::string m_message;
const char* m_file;
unsigned m_line;
};
class GIT2WRAP_EXPORT libgit2

@@ -45,6 +54,34 @@ private:

int m_cinit = 0;
};
class GIT2WRAP_EXPORT branch
{
public:
branch(git_reference* ref, git_branch_t type);
branch() = default;
branch(const branch&) = delete;
branch& operator=(const branch&) = delete;
branch(branch&& rhs) noexcept;
branch& operator=(branch&& rhs) noexcept;
~branch();
git_reference* get_reference() { return m_ref; }
const git_reference* get_reference() const { return m_ref; }
git_branch_t get_type() const { return m_type; }
const std::string& get_name();
private:
git_reference* m_ref = nullptr;
git_branch_t m_type = {};
std::string m_name;
};
class GIT2WRAP_EXPORT repository
{
public:

@@ -70,6 +107,38 @@ public:

unsigned flags,
const char* ceiling_dirs);
struct branch_iterator
{
explicit branch_iterator(git_branch_iterator* iter);
branch_iterator() = default;
branch_iterator(const branch_iterator&) = delete;
branch_iterator& operator=(const branch_iterator&) = delete;
branch_iterator(branch_iterator&&) = default;
branch_iterator& operator=(branch_iterator&&) = default;
~branch_iterator();
branch& operator*() { return m_branch; }
branch* operator->() { return &m_branch; }
branch_iterator& operator++();
friend bool operator==(const branch_iterator& lhs,
const branch_iterator& rhs);
friend bool operator!=(const branch_iterator& lhs,
const branch_iterator& rhs);
git_branch_iterator* m_iter = nullptr;
private:
branch m_branch;
};
branch_iterator branch_begin(git_branch_t list_flags) const;
branch_iterator branch_end() const;
private:
git_repository* m_repo = nullptr;
};

diff --git a/source/branch.cpp b/source/branch.cpp

@@ -0,0 +1,48 @@

#include "git2wrap/git2wrap.hpp"
namespace git2wrap
{
branch::branch(git_reference* ref, git_branch_t type)
: m_ref(ref)
, m_type(type)
{
}
branch::branch(branch&& rhs) noexcept
{
std::swap(m_ref, rhs.m_ref);
std::swap(m_type, rhs.m_type);
std::swap(m_name, rhs.m_name);
}
branch& branch::operator=(branch&& rhs) noexcept
{
std::swap(m_ref, rhs.m_ref);
std::swap(m_type, rhs.m_type);
std::swap(m_name, rhs.m_name);
return *this;
}
branch::~branch()
{
git_reference_free(m_ref);
m_ref = nullptr;
}
const std::string& branch::get_name()
{
if (!m_name.empty()) {
return m_name;
}
const char* name = nullptr;
if (auto err = git_branch_name(&name, m_ref)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return m_name = name;
}
} // namespace git2wrap

diff --git a/source/libgit2.cpp b/source/libgit2.cpp

@@ -6,7 +6,7 @@ namespace git2wrap

libgit2::libgit2()
{
if (m_cinit = git_libgit2_init(); m_cinit < 0) {
throw error(m_cinit, git_error_last());
throw error(m_cinit, git_error_last(), __FILE__, __LINE__);
}
}

diff --git a/source/repository.cpp b/source/repository.cpp

@@ -11,20 +11,21 @@ repository::repository(git_repository* repo)

repository::repository(const char* path, unsigned is_bare)
{
if (auto err = git_repository_init(&m_repo, path, is_bare)) {
throw error(err, git_error_last());
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
repository::repository(const char* path, init_options* opts)
{
if (auto err = git_repository_init_ext(&m_repo, path, opts)) {
throw error(err, git_error_last());
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
repository::~repository()
{
git_repository_free(m_repo);
m_repo = nullptr;
}
repository repository::clone(const char* url,

@@ -34,7 +35,7 @@ repository repository::clone(const char* url,

git_repository* repo = nullptr;
if (auto err = git_clone(&repo, url, local_path, options)) {
throw error(err, git_error_last());
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return repository(repo);

@@ -45,7 +46,7 @@ repository repository::open(const char* path)

git_repository* repo = nullptr;
if (auto err = git_repository_open(&repo, path)) {
throw error(err, git_error_last());
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return repository(repo);

@@ -58,10 +59,60 @@ repository repository::open(const char* path,

git_repository* repo = nullptr;
if (auto err = git_repository_open_ext(&repo, path, flags, ceiling_dirs)) {
throw error(err, git_error_last());
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return repository(repo);
}
repository::branch_iterator::branch_iterator(git_branch_iterator* iter)
: m_iter(iter)
{
++*this;
}
repository::branch_iterator::~branch_iterator()
{
git_branch_iterator_free(m_iter);
m_iter = nullptr;
}
repository::branch_iterator& repository::branch_iterator::operator++()
{
git_reference* ref = nullptr;
git_branch_t type = {};
if (auto err = git_branch_next(&ref, &type, m_iter)) {
if (err != GIT_ITEROVER) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
}
m_branch = {ref, type};
return *this;
}
repository::branch_iterator repository::branch_begin(
git_branch_t list_flags) const
{
git_branch_iterator* iter = nullptr;
if (auto err = git_branch_iterator_new(&iter, m_repo, list_flags)) {
throw error(err, git_error_last(), __FILE__, __LINE__);
}
return branch_iterator(iter);
}
repository::branch_iterator repository::branch_end() const // NOLINT
{
return {};
}
bool operator!=(const repository::branch_iterator& lhs,
const repository::branch_iterator& rhs)
{
return lhs.m_branch.get_reference() != rhs.m_branch.get_reference();
}
} // namespace git2wrap