ggit_revision_walker_new ()

GgitRevisionWalker *
ggit_revision_walker_new (GgitRepository *repository,
                          GError **error);

Creates a new revision walker to iterate through repository .

This revision walker uses a custom memory pool and an internal commit cache, so it is relatively expensive to allocate.

For maximum performance, this revision walker should be reused for different walks.

This revision walker is *not* thread safe: it may only be used to walk a repository on a single thread; however, it is possible to have several revision walkers in several different threads walking the same repository.

ggit_revision_walker_reset ()

void
ggit_revision_walker_reset (GgitRevisionWalker *walker);

Resets the revision walker for reuse.

This will clear all the pushed and hidden commits, and leave the walker in a blank state (just like at creation) ready to receive new commit pushes and start a new walk.

The revision walk is automatically reset when a walk is over.

ggit_revision_walker_push ()

void
ggit_revision_walker_push (GgitRevisionWalker *walker,
                           GgitOId *oid,
                           GError **error);

Marks a commit to start traversal from.

The given OID must belong to a commit on the walked repository.

The given commit will be used as one of the roots when starting the revision walk. At least one commit must be pushed the repository before a walk can be started.

ggit_revision_walker_hide ()

void
ggit_revision_walker_hide (GgitRevisionWalker *walker,
                           GgitOId *oid,
                           GError **error);

Marks a commit (and its ancestors) uninteresting for the output.

The given OID must belong to a commit on the walked repository.

The resolved commit and all its parents will be hidden from the output on the revision walk.

ggit_revision_walker_hide_glob ()

void
ggit_revision_walker_hide_glob (GgitRevisionWalker *walker,
                                const gchar *item,
                                GError **error);

Hide all OIDs pointed to by references that match the given glob pattern to the revsision walker. A leading 'refs/' is implied if not present, as well as a trailing '/ \ *' if the glob lacks '?', '\ *' or '['.

ggit_revision_walker_hide_head ()

void
ggit_revision_walker_hide_head (GgitRevisionWalker *walker,
                                GError **error);

Hide the OID of the current HEAD to the revision walker.

ggit_revision_walker_hide_ref ()

void
ggit_revision_walker_hide_ref (GgitRevisionWalker *walker,
                               const gchar *item,
                               GError **error);

Hide the OID pointed to by the named reference to the revision walker.

ggit_revision_walker_push_glob ()

void
ggit_revision_walker_push_glob (GgitRevisionWalker *walker,
                                const gchar *item,
                                GError **error);

Push all OIDs pointed to by references that match the given glob pattern to the revsision walker. A leading 'refs/' is implied if not present, as well as a trailing '/ \ *' if the glob lacks '?', '\ *' or '['.

ggit_revision_walker_push_head ()

void
ggit_revision_walker_push_head (GgitRevisionWalker *walker,
                                GError **error);

Push the OID of the current HEAD to the revision walker.

ggit_revision_walker_push_range ()

void
ggit_revision_walker_push_range (GgitRevisionWalker *walker,
                                 const gchar *range,
                                 GError **error);

Push and hide the respective endpoints of the given range. The range should be of the form: &ltcommit&gt..<commit>, where each <commit> is in the form accepted by revparse. The left-hand commit will be hidden and the right-hand commit pushed.

ggit_revision_walker_push_ref ()

void
ggit_revision_walker_push_ref (GgitRevisionWalker *walker,
                               const gchar *item,
                               GError **error);

Push the OID pointed to by the named reference to the revision walker.

ggit_revision_walker_next ()

GgitOId *
ggit_revision_walker_next (GgitRevisionWalker *walker,
                           GError **error);

Gets the next commit from the revision walk.

The initial call to this method is *not* blocking when iterating through a repository with a time-sorting mode.

Iterating with Topological or inverted modes makes the initial call blocking to preprocess the commit list, but this block should be mostly unnoticeable on most repositories (topological preprocessing times at 0.3s on the git.git repo).

The revision walker is reset when the walk is over.

ggit_revision_walker_set_sort_mode ()

void
ggit_revision_walker_set_sort_mode (GgitRevisionWalker *walker,
                                    GgitSortMode sort_mode);

Change the sorting mode when iterating through the repository's contents.

Changing the sorting mode resets the walker.

ggit_revision_walker_get_repository ()

GgitRepository *
ggit_revision_walker_get_repository (GgitRevisionWalker *walker);

Gets the repository on which this walker is operating.

GgitRevisionWalker

typedef struct _GgitRevisionWalker GgitRevisionWalker;

Represents a revision walker.

struct GgitRevisionWalkerClass

struct GgitRevisionWalkerClass {
};

The class structure for GgitRevisionWalkerClass.

enum GgitSortMode

The type of sorting mode for the revision walker.

The “repository” property

  “repository”               GgitRepository *

The repository where to make the walking.

Flags: Read / Write / Construct