/**
* ggit_branch_get_name:
* @branch: a #GgitBranch.
* @error: a #GError for error reporting, or %NULL.
*
* Gets the name of the given local or remote branch.
*
* Returns: (transfer none) (nullable): the name of the given local or remote branch or %NULL.
*/
const gchar *
ggit_branch_get_name (GgitBranch *branch,
GError **error)
{
const gchar *out;
gint ret;
g_return_val_if_fail (GGIT_IS_BRANCH (branch), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_branch_name (&out,
_ggit_native_get (branch));
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return out;
}
/**
* ggit_patch_new_from_diff:
* @diff: a #GgitDiff.
* @idx: index into diff list.
* @error: a #GError for error reporting, or %NULL.
*
* The #GgitPatch is a newly created object contains the text diffs
* for the delta. You have to call ggit_patch_unref() when you are
* done with it. You can use the patch object to loop over all the hunks
* and lines in the diff of the one delta.
*
* Returns: (transfer full): a newly created #GgitPatch.
*/
GgitPatch *
ggit_patch_new_from_diff (GgitDiff *diff,
gsize idx,
GError **error)
{
git_patch *patch;
gint ret;
g_return_val_if_fail (GGIT_IS_DIFF (diff), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_patch_from_diff (&patch, _ggit_native_get (diff), idx);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return _ggit_patch_wrap (patch);
}
/**
* ggit_config_get_string:
* @config: a #GgitConfig.
* @name: the name of the configuration value.
* @error: a #GError for error reporting, or %NULL.
*
* Get the configuration value of @name as string.
*
* Returns: (allow-none): the string value of @name, or %NULL if such a value
* does not exist
*
**/
const gchar *
ggit_config_get_string (GgitConfig *config,
const gchar *name,
GError **error)
{
gint ret;
const gchar *retval;
g_return_val_if_fail (GGIT_IS_CONFIG (config), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
ret = git_config_get_string (&retval, _ggit_native_get (config), name);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return retval;
}
/**
* ggit_config_set_bool:
* @config: a #GgitConfig.
* @name: the name of the configuration value.
* @value: the new value.
* @error: a #GError for error reporting, or %NULL.
*
* Set a boolean value.
*
* Returns: %TRUE if the value was successfully set, %FALSE otherwise.
*
**/
gboolean
ggit_config_set_bool (GgitConfig *config,
const gchar *name,
gboolean value,
GError **error)
{
gint ret;
g_return_val_if_fail (GGIT_IS_CONFIG (config), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
ret = git_config_set_bool (_ggit_native_get (config), name, value ? 1 : 0);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return FALSE;
}
return TRUE;
}
/**
* ggit_config_get_int64:
* @config: a #GgitConfig.
* @name: the name of the configuration value.
* @error: a #GError for error reporting, or %NULL.
*
* Get a int64 configuration value.
*
* Returns: the value.
*
**/
gint64
ggit_config_get_int64 (GgitConfig *config,
const gchar *name,
GError **error)
{
gint ret;
int64_t retval;
g_return_val_if_fail (GGIT_IS_CONFIG (config), 0);
g_return_val_if_fail (name != NULL, 0);
g_return_val_if_fail (error == NULL || *error == NULL, 0);
ret = git_config_get_int64 (&retval, _ggit_native_get (config), name);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return 0;
}
return (gint64)retval;
}
/**
* ggit_tree_get_by_name:
* @tree: a #GgitTree.
* @name: a filename.
*
* Get a tree entry by name.
*
* Returns: (transfer full): a #GgitTreeEntry.
*
**/
GgitTreeEntry *
ggit_tree_get_by_name (GgitTree *tree,
const gchar *name)
{
git_tree *t;
GgitTreeEntry *entry = NULL;
const git_tree_entry *tree_entry;
g_return_val_if_fail (GGIT_IS_TREE (tree), NULL);
g_return_val_if_fail (name != NULL, NULL);
t = _ggit_native_get (tree);
tree_entry = git_tree_entry_byname (t, name);
if (tree_entry != NULL)
{
entry = _ggit_tree_entry_wrap ((git_tree_entry *)tree_entry, FALSE);
}
return entry;
}
/**
* ggit_remote_new_anonymous:
* @repository: a #GgitRepository.
* @url: the remote repository's URL.
* @error: a #GError for error reporting, or %NULL.
*
* Creates a remote with the specified refspec in memory. You can use
* this when you have a URL instead of a remote's name.
*
* Returns: (transfer full) (nullable): a newly allocated #GgitRemote or %NULL.
*/
GgitRemote *
ggit_remote_new_anonymous (GgitRepository *repository,
const gchar *url,
GError **error)
{
gint ret;
git_remote *remote;
g_return_val_if_fail (GGIT_IS_REPOSITORY (repository), NULL);
g_return_val_if_fail (url != NULL, NULL);
ret = git_remote_create_anonymous (&remote,
_ggit_native_get (repository),
url);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return _ggit_remote_wrap (remote);
}
/**
* ggit_ref_lookup:
* @ref: a #GgitRef.
* @error: a #GError for error reporting, or %NULL.
*
* Convenient method to resolve a reference to an object.
*
* Returns: (transfer full): a #GgitObject.
*
**/
GgitObject *
ggit_ref_lookup (GgitRef *ref,
GError **error)
{
git_object *obj;
git_reference *r;
gint ret;
GgitRef *lref;
g_return_val_if_fail (GGIT_IS_REF (ref), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
lref = ggit_ref_resolve (ref, error);
if (lref == NULL)
{
return NULL;
}
r = _ggit_native_get (lref);
ret = git_object_lookup (&obj,
git_reference_owner (r),
git_reference_target (r),
GIT_OBJ_ANY);
g_object_unref (lref);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return ggit_utils_create_real_object (obj, TRUE);
}
/**
* ggit_ref_resolve:
* @ref: a #GgitRef.
* @error: a #GError for error reporting, or %NULL.
*
* Resolves a symbolic reference.
*
* This method iteratively peels a symbolic reference
* until it resolves to a direct reference to an OID.
*
* If a direct reference is passed as an argument,
* that reference is returned immediately.
*
* Returns: (transfer full): the resolved reference to the peeled one.
*/
GgitRef *
ggit_ref_resolve (GgitRef *ref,
GError **error)
{
GgitRef *rev_ref = NULL;
git_reference *reference;
gint ret;
g_return_val_if_fail (ref != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_reference_resolve (&reference, _ggit_native_get (ref));
if (ret == GIT_OK)
{
rev_ref = _ggit_ref_wrap (reference, FALSE);
}
else
{
_ggit_error_set (error, ret);
}
return rev_ref;
}
