.
1 /*
2 * libgit2 Vala binding
3 *
4 * Homepage: http://libgit2.github.com/
5 * VAPI Homepage: https://github.com/apmasell/vapis/blob/master/libgit2.vapi
6 * VAPI Maintainer: Andre Masella <andre@masella.name>
7 *
8 * This file is part of libgit2, distributed under the GNU GPL v2 with
9 * a Linking Exception. For full terms see the included COPYING file.
10 */
11
12 /**
13 * Library to access the contents of git repositories
14 *
15 * libgit2 can access and manipulate the contents of git repositories. To begin, create an instance of a {@link Git.Repository} like so:
16 * {{{
17 * Git.Repository? repo;
18 * if (Git.Repository.open(out repo, "/path/to/repo") != Git.Error.OK) {
19 * stderr.printf("Could not open repository because: %s\n", Git.ErrorInfo.get_last().message);
20 * return false;
21 * }
22 * }}}
23 * Then use the methods of //repo// to access the repository.
24 */
25 [CCode(cheader_filename = "git2.h")]
26 namespace Git {
27 namespace Configuration {
28 /**
29 * Generic backend that implements the interface to
30 * access a configuration file
31 */
32 [CCode(cname = "git_config_backend", has_type_id = false, default_value = "GIT_CONFIG_BACKEND_INIT")]
33 public struct backend {
34 [CCode(cname = "GIT_CONFIG_BACKEND_VERSION")]
35 public const uint VERSION;
36 public uint version;
37 public unowned Config cfg;
38 public Delete @delete;
39 [CCode(cname = "foreach")]
40 public ForEach for_each;
41 public Free free;
42 public Get @get;
43 [CCode(cname = "get_multivar")]
44 public GetMulti get_multi;
45 [CCode(cname = "refersh")]
46 public Refresh refresh;
47 public Open open;
48 public Set @set;
49 public SetMulti set_multi;
50 }
51
52 [CCode(cname = "git_config_file_delete_cb", has_type_id = false, has_target = false)]
53 public delegate int Delete(backend backend, string key);
54 [CCode(cname = "git_config_file_foreach_cb", has_type_id = false, has_target = false)]
55 public delegate int ForEach(backend backend, string regex, ConfigForEach config_for_each);
56 [CCode(cname = "git_config_file_free_cb", has_type_id = false, has_target = false)]
57 public delegate void Free(backend backend);
58 [CCode(cname = "git_config_file_get_cb", has_type_id = false, has_target = false)]
59 public delegate int Get(backend backend, string key, out string value);
60 [CCode(cname = "git_config_file_get_mulivar_cb", has_type_id = false, has_target = false)]
61 public delegate int GetMulti(backend backend, string key, string? regexp, Setter func);
62 [CCode(cname = "git_config_file_refresh", has_type_id = false, has_target = false)]
63 public delegate Error Refresh(backend backend);
64 [CCode(cname = "git_config_file_set_cb", has_type_id = false, has_target = false)]
65 public delegate int Setter(string val);
66 [CCode(cname = "git_config_file_open_cb", has_type_id = false, has_target = false)]
67 public delegate int Open(backend backend);
68 [CCode(cname = "git_config_file_set_cb", has_type_id = false, has_target = false)]
69 public delegate int Set(backend backend, string key, string value);
70 [CCode(cname = "git_config_file_set_multivar_cb", has_type_id = false, has_target = false)]
71 public delegate int SetMulti(backend backend, string name, string regexp, string val);
72 }
73 namespace Database {
74 /**
75 * An open object database handle
76 */
77 [CCode(cname = "git_odb", free_function = "git_odb_close", has_type_id = false)]
78 [Compact]
79 public class Handle {
80 /**
81 * Create a new object database with no backends.
82 *
83 * Before the ODB can be used for read/writing, a custom database
84 * backend must be manually added using {@link Handle.add_backend}.
85 *
86 * @param db location to store the database pointer, if opened. Set to null if the open failed.
87 */
88 [CCode(cname = "git_odb_new")]
89 public static Error create(out Handle? db);
90
91 /**
92 * Create a new object database and automatically add
93 * the two default backends.
94 *
95 * Automatically added are:
96 * - {@link backend.create_loose}: read and write loose object files
97 * from disk, assuming //objects_dir// as the Objects folder
98 *
99 * - {@link backend.create_pack}: read objects from packfiles,
100 * assuming //objects_dir// as the Objects folder which
101 * contains a //pack// folder with the corresponding data
102 *
103 * @param db location to store the database pointer, if opened.
104 * Set to null if the open failed.
105 * @param objects_dir path of the backends' //objects// directory.
106 */
107 [CCode(cname = "git_odb_open")]
108 public static Error open(out Handle db, string objects_dir);
109
110 /**
111 * Add a custom backend to an existing Object DB; this
112 * backend will work as an alternate.
113 *
114 * Alternate backends are always checked for objects ''after''
115 * all the main backends have been exhausted.
116 *
117 * The backends are checked in relative ordering, based on the
118 * value of the //priority// parameter.
119 *
120 * Writing is disabled on alternate backends.
121 *
122 * @param backend the backend instance
123 * @param priority Value for ordering the backends queue
124 */
125 [CCode(cname = "git_odb_add_alternate")]
126 public Error add_alternate(backend backend, int priority);
127
128 /**
129 * Add a custom backend to an existing Object DB
130 *
131 * The backends are checked in relative ordering, based on the
132 * value of the //priority// parameter.
133 * @param backend the backend instance
134 * @param priority Value for ordering the backends queue
135 */
136 [CCode(cname = "git_odb_add_backend")]
137 public Error add_backend(backend backend, int priority);
138
139 /**
140 * Determine if the given object can be found in the object database.
141 *
142 * @param id the object to search for.
143 */
144 [CCode(cname = "git_odb_exists")]
145 public bool contains(object_id id);
146
147 /**
148 * Create a "fake" repository to wrap an object database
149 *
150 * Create a repository object to wrap an object database to be used with
151 * the API when all you have is an object database. This doesn't have any
152 * paths associated with it, so use with care.
153 */
154 [CCode(cname = "git_repository_wrap_odb", instance_pos = -1)]
155 public Error create_repository(out Repository? repository);
156
157 /**
158 * List all objects available in the database
159 *
160 * The callback will be called for each object available in the
161 * database. Note that the objects are likely to be returned in the index
162 * order, which would make accessing the objects in that order inefficient.
163 */
164 [CCode(cname = "git_odb_foreach")]
165 public Error for_each(ObjectIdForEach object_for_each);
166
167 /**
168 * Read an object from the database.
169 *
170 * This method queries all available ODB backends
171 * trying to read the given id.
172 *
173 * @param obj pointer where to store the read object
174 * @param id identity of the object to read.
175 */
176 [CCode(cname = "git_odb_read", instance_pos = 1.2)]
177 public Error read(out Object obj, object_id id);
178
179 /**
180 * Read an object from the database, given a prefix
181 * of its identifier.
182 *
183 * This method queries all available ODB backends
184 * trying to match the //len// first hexadecimal
185 * characters of the //short_id//.
186 * The remaining //({@link object_id.HEX_SIZE}-len)*4// bits of
187 * //short_id// must be 0s.
188 * //len// must be at least {@link object_id.MIN_PREFIX_LENGTH},
189 * and the prefix must be long enough to identify
190 * a unique object in all the backends; the
191 * method will fail otherwise.
192 *
193 * The returned object is reference counted and
194 * internally cached, so it should be closed
195 * by the user once it's no longer in use.
196 *
197 * @param obj pointer where to store the read object
198 * @param short_id a prefix of the id of the object to read.
199 * @param len the length of the prefix
200 */
201 [CCode(cname = "git_odb_read_prefix", instance_pos = 1.2)]
202 public Error read_by_prefix(out Object obj, object_id short_id, size_t len);
203
204 /**
205 * Read the header of an object from the database, without
206 * reading its full contents.
207 *
208 * The header includes the length and the type of an object.
209 *
210 * Note that most backends do not support reading only the header
211 * of an object, so the whole object will be read and then the
212 * header will be returned.
213 *
214 * @param len the length of the object
215 * @param type the type of the object
216 * @param id identity of the object to read.
217 */
218 [CCode(cname = "git_odb_read_header", instance_pos = 2.3)]
219 public Error read_header(out size_t len, out ObjectType type, object_id id);
220
221 /**
222 * Refresh the object database to load newly added files.
223 *
224 * If the object databases have changed on disk while the library is
225 * running, this function will force a reload of the underlying indexes.
226 *
227 * Use this function when you're confident that an external application
228 * has tampered with the ODB.
229 *
230 * Note that it is not necessary to call this function at all. The
231 * library will automatically attempt to refresh the ODB when a lookup
232 * fails, to see if the looked up object exists on disk but hasn't been
233 * loaded yet.
234 */
235 [CCode(cname = "git_odb_refresh")]
236 public Error refresh();
237
238 /**
239 * Open a stream to write an object into the ODB
240 *
241 * The type and final length of the object must be specified
242 * when opening the stream.
243 *
244 * The returned stream will be of type {@link StreamMode.WRONLY} and
245 * will have the following methods:
246 *
247 * * {@link stream.write}: write //n// bytes into the stream
248 * * {@link stream.finalize_write}: close the stream and store the object in the ODB
249 *
250 * The streaming write won't be effective until {@link stream.finalize_write}
251 * is called and returns without an error
252 *
253 * @param stream where to store the stream
254 * @param size final size of the object that will be written
255 * @param type type of the object that will be written
256 */
257 [CCode(cname = "git_odb_open_wstream", instance_pos = 1.2)]
258 public Error open_write_stream(out stream stream, size_t size, ObjectType type);
259
260 /**
261 * Open a stream to read an object from the ODB
262 *
263 * Note that most backends do ''not'' support streaming reads
264 * because they store their objects as compressed/delta'ed blobs.
265 *
266 * It's recommended to use {@link Handle.read} instead, which is
267 * assured to work on all backends.
268 *
269 * The returned stream will be of type {@link StreamMode.RDONLY} and
270 * will have the following methods:
271 *
272 * * {@link stream.read}: read //n// bytes from the stream
273 *
274 * @param stream where to store the stream
275 * @param id id of the object the stream will read from
276 */
277 [CCode(cname = "git_odb_open_rstream")]
278 public Error open_read_stream(out stream stream, object_id id);
279
280 /**
281 * Write an object directly into the ODB
282 *
283 * This method writes a full object straight into the ODB.
284 * For most cases, it is preferred to write objects through a write
285 * stream, which is both faster and less memory intensive, specially
286 * for big objects.
287 *
288 * This method is provided for compatibility with custom backends
289 * which are not able to support streaming writes
290 *
291 * @param id pointer to store the id result of the write
292 * @param data buffer with the data to store
293 * @param type type of the data to store
294 */
295 [CCode(cname = "git_odb_write", instance_pos = 1.2)]
296 public Error write(object_id id, [CCode(array_length_Type = "size_t")] uint8[] data, ObjectType type);
297 }
298
299 /**
300 * An object read from the database
301 */
302 [CCode(cname = "git_odb_object", free_function = "git_odb_object_free", has_type_id = false)]
303 [Compact]
304 public class Object {
305
306 /**
307 * The data of an ODB object
308 *
309 * This is the uncompressed, raw data as read from the ODB,
310 * without the leading header.
311 */
312 public uint8[] data {
313 [CCode(cname = "git_odb_object_data", array_length_cexpr = "git_odb_object_size")]
314 get;
315 }
316
317 /**
318 * The id of an ODB object
319 */
320 public object_id? id {
321 [CCode(cname = "git_odb_object_id")]
322 get;
323 }
324
325 /**
326 * The type of an ODB object
327 */
328 public ObjectType type {
329 [CCode(cname = "git_odb_object_type")]
330 get;
331 }
332 }
333
334 /**
335 * A custom backend in an ODB
336 */
337 [CCode(cname = "git_odb_backend", has_type_id = false, default_value = "GIT_ODB_BACKEND_INIT")]
338 public struct backend {
339 [CCode(cname = "GIT_ODB_BACKEND_VERSION")]
340 public const uint VERSION;
341 public uint version;
342 public unowned Handle odb;
343
344 public BackendExists exists;
345 public BackendFree free;
346 [CCode(cname = "foreach")]
347 public BackendForEach for_each;
348 public BackendRead read;
349 public BackendReadHeader read_header;
350 public BackendReadPrefix read_prefix;
351 [CCode(cname = "readstream")]
352 public BackendReadStream read_stream;
353 public BackendWrite write;
354 public BackendWritePack write_pack;
355 [CCode(cname = "writestream")]
356 public BackendWriteStream write_stream;
357
358 [CCode(cname = "git_odb_backend_loose")]
359 public static Error create_loose(out backend backend, string objects_dir);
360 [CCode(cname = "git_odb_backend_one_pack")]
361 public static Error create_one_pack(out backend backend, string index_file);
362 [CCode(cname = "git_odb_backend_pack")]
363 public static Error create_pack(out backend backend, string objects_dir);
364 [CCode(cname = "git_odb_backend_malloc", simple_generics = true)]
365 public T malloc<T>(size_t len);
366 }
367
368 /**
369 * A stream to read/write from the ODB
370 */
371 [CCode(cname = "git_odb_stream", has_type_id = false)]
372 public struct stream {
373 public unowned backend? backend;
374
375 public StreamMode mode;
376
377 public StreamFinalizeWrite finalize_write;
378 public StreamFree free;
379 public StreamRead read;
380 public StreamWrite write;
381 }
382 /**
383 * A stream to write a pack file to the ODB
384 */
385 [CCode(cname = "git_odb_writepack", has_type_id = false)]
386 public struct write_pack {
387 public unowned backend? backend;
388 [CCode(cname = "add")]
389 public WritePackAdd add;
390 [CCode(cname = "commit")]
391 public WritePackCommit commit;
392 [CCode(cname = "free")]
393 public WritePackFree free;
394 }
395 /**
396 * Streaming mode
397 */
398 [CCode(cname = "git_odb_streammode", cprefix = "GIT_STREAM_", has_type_id = false)]
399 public enum StreamMode {
400 RDONLY,
401 WRONLY,
402 RW
403 }
404 [CCode(has_target = false, has_type_id = false)]
405 public delegate bool BackendExists(backend self, object_id id);
406 [CCode(has_target = false, has_type_id = false)]
407 public delegate void BackendFree(backend self);
408 [CCode(has_target = false, has_type_id = false)]
409 public delegate Error BackendForEach(backend self, ObjectIdForEach cb);
410 /**
411 * Read each return to libgit2 a buffer which will be freed later.
412 *
413 * The buffer should be allocated using the function {@link backend.malloc} to
414 * ensure that it can be safely freed later.
415 */
416 [CCode(has_target = false, has_type_id = false)]
417 public delegate Error BackendRead([CCode(array_length_type = "size_t")] out uint8[] data, out ObjectType type, backend self, object_id id);
418 /**
419 * Find a unique object given a prefix
420 *
421 * The id given must be so that the remaining
422 * ({@link object_id.HEX_SIZE} - len)*4 bits are 0s.
423 */
424 [CCode(has_target = false, has_type_id = false)]
425 public delegate Error BackendReadHeader(out size_t size, out ObjectType type, backend self, object_id id);
426 [CCode(has_target = false, has_type_id = false)]
427 public delegate Error BackendReadPrefix(out object_id id, [CCode(array_length_type = "size_t")] out uint8[] data, out ObjectType type, backend self, object_id id_prefix, size_t len);
428 [CCode(has_target = false, has_type_id = false)]
429 public delegate Error BackendReadStream(out stream stream, backend self, object_id id);
430 [CCode(has_target = false, has_type_id = false)]
431 public delegate Error BackendWrite(out object_id id, backend self, [CCode(array_length_type = "size_t")] out uint8[] data, ObjectType type);
432 [CCode(has_target = false, has_type_id = false)]
433 public delegate Error BackendWriteStream(out stream stream, backend self, size_t size, ObjectType type);
434 [CCode(has_target = false, has_type_id = false)]
435 public delegate int BackendWritePack(out write_pack write_pack, backend self, TransferProgress progress);
436
437 [CCode(has_target = false, has_type_id = false)]
438 public delegate Error StreamFinalizeWrite(out object_id id, stream stream);
439 [CCode(has_target = false, has_type_id = false)]
440 public delegate void StreamFree(stream stream);
441 [CCode(has_target = false, has_type_id = false)]
442 public delegate int StreamRead(stream stream, [CCode(array_length_type = "size_t")] uint8[] buffer);
443 [CCode(has_target = false, has_type_id = false)]
444 public delegate int StreamWrite(stream stream, [CCode(array_length_type = "size_t")] uint8[] buffer);
445
446 [CCode(has_target = false)]
447 public delegate int WritePackAdd(write_pack write_pack, [CCode(array_length_type = "size_t")] uint8[] data, transfer_progress stats);
448 [CCode(has_target = false)]
449 public delegate int WritePackCommit(write_pack write_pack, transfer_progress stats);
450 [CCode(has_target = false)]
451 public delegate void WritePackFree(write_pack write_pack);
452 }
453 namespace Threads {
454 /**
455 * Init the threading system.
456 *
457 * If libgit2 has been built with GIT_THREADS
458 * on, this function must be called once before
459 * any other library functions.
460 *
461 * If libgit2 has been built without GIT_THREADS
462 * support, this function is a no-op.
463 */
464 [CCode(cname = "git_threads_init")]
465 public Error init();
466
467 /**
468 * Shutdown the threading system.
469 *
470 * If libgit2 has been built with GIT_THREADS
471 * on, this function must be called before shutting
472 * down the library.
473 *
474 * If libgit2 has been built without GIT_THREADS
475 * support, this function is a no-op.
476 */
477 [CCode(cname = "git_threads_shutdown")]
478 public void shutdown();
479 }
480 namespace Version {
481 [CCode(cname = "LIBGIT2_VERSION")]
482 public const string VERSION;
483 [CCode(cname = "LIBGIT2_VER_MAJOR")]
484 public const int MAJOR;
485 [CCode(cname = "LIBGIT2_VER_MINOR")]
486 public const int MINOR;
487 [CCode(cname = "LIBGIT2_VER_REVISION")]
488 public const int REVISION;
489 /**
490 * Return the version of the libgit2 library
491 * being currently used.
492 *
493 * @param major Store the major version number
494 * @param minor Store the minor version number
495 * @param rev Store the revision (patch) number
496 */
497 [CCode(cname = "git_libgit2_version")]
498 public void get_version(out int major, out int minor, out int rev);
499 }
500
501 /*
502 * Attribute management routines
503 */
504 [CCode(cname = "git_repository", cheader_filename = "git2/attr.h", has_type_id = false)]
505 public class Attr {
506 [CCode(cname = "git_attr_t", cprefix = "GIT_ATTR_", has_type_id = false)]
507 public enum AttrType {
508 [CCode(cname = "GIT_ATTR_UNSPECIFIED_T")]
509 UNSPECIFIED,
510 [CCode(cname = "GIT_ATTR_TRUE_T")]
511 TRUE,
512 [CCode(cname = "GIT_ATTR_FALSE_T")]
513 FALSE,
514 [CCode(cname = "GIT_ATTR_VALUE_T")]
515 VALUE;
516 /**
517 * Return the value type for a given attribute.
518 *
519 * This can be either {@link TRUE}, {@link FALSE}, {@link UNSPECIFIED}
520 * (if the attribute was not set at all), or {@link VALUE}, if the
521 * attribute was set to an actual string.
522 *
523 * If the attribute has a {@link VALUE} string, it can be accessed
524 * normally as a string.
525 */
526 [CCode(cname = "git_attr_value")]
527 public static AttrType from(string attr);
528 }
529
530 /**
531 * Checks if an attribute is set on.
532 *
533 * In core git parlance, this the value for "Set" attributes.
534 */
535 [CCode(cname = "GIT_ATTR_TRUE")]
536 public static bool is_true(string? attr);
537 /**
538 * Checks if an attribute is set off.
539 *
540 * In core git parlance, this is the value for attributes that are "Unset"
541 * (not to be confused with values that a "Unspecified").
542 */
543 [CCode(cname = "GIT_ATTR_FALSE")]
544 public static bool is_false(string? attr);
545 /**
546 * Checks if an attribute is set to a value (as opposied to TRUE, FALSE or
547 * UNSPECIFIED).
548 */
549 [CCode(cname = "GIT_ATTR_SET_TO_VALUE")]
550 public static bool is_set(string? attr);
551 /*
552 * Checks if an attribute is unspecified. This may be due to the attribute
553 * not being mentioned at all or because the attribute was explicitly set
554 * unspecified via the `!` operator.
555 */
556 [CCode(cname = "GIT_ATTR_UNSPECIFIED")]
557 public static bool is_unspecified(string? attr);
558
559 /**
560 * Add a macro definition.
561 *
562 * Macros will automatically be loaded from the top level .gitattributes
563 * file of the repository (plus the build-in "binary" macro). This
564 * function allows you to add others. For example, to add the default
565 * macro, you would call:
566 * {{{
567 * repo.attributes.add_macro("binary", "-diff -crlf");
568 * }}}
569 */
570 [CCode(cname = "git_attr_add_macro")]
571 public Error add_macro(string name, string val);
572
573 /**
574 * Lookup attribute for path returning string caller must free
575 */
576 [CCode(cname = "git_attr_get")]
577 public Error lookup(AttrCheck flags, string path, string name, out unowned string? val);
578
579 /**
580 * Lookup list of attributes for path, populating array of strings
581 *
582 * Use this if you have a known list of attributes that you want to
583 * look up in a single call. This is somewhat more efficient than
584 * calling {@link lookup} multiple times.
585 *
586 * For example, you might write:
587 * {{{
588 * string attrs[] = { "crlf", "diff", "foo" };
589 * string results[];
590 * repo.attributes.lookup_many(AttrCheck.FILE_THEN_INDEX, "my/fun/file.c", attrs, out values);
591 * }}}
592 * Then you could loop through the 3 values to get the settings for
593 * the three attributes you asked about.
594 *
595 * @param path The path inside the repo to check attributes. This does not
596 * have to exist, but if it does not, then it will be treated as a plain
597 * file (i.e. not a directory).
598 * @param names The attribute names.
599 * @param values The values of the attributes.
600 */
601 [CCode(cname = "_vala_git_attr_get_many")]
602 public Error lookup_many(AttrCheck flags, string path, string[] names, out string[] values) {
603 unstr[] temp = new unstr[names.length];
604 var e = _lookup_many(flags, path, names, temp);
605 values = new string[names.length];
606 for (var it = 0; it < temp.length; it++) {
607 values[it] = temp[it].dup();
608 }
609 return e;
610 }
611
612 [CCode(cname = "git_attr_get_many")]
613 private Error _lookup_many(AttrCheck flags, string path, [CCode(array_length_pos = 2.1, array_length_type = "size_t")] string[] names, void* values);
614
615 /**
616 * Perform an operation on each attribute of a path.
617 * @param path The path inside the repo to check attributes. This does not
618 * have to exist, but if it does not, then it will be treated as a plain
619 * file (i.e. not a directory).
620 * @param attribute_for_each The function that will be invoked on each
621 * attribute and attribute value. The name parameter will be the name of
622 * the attribute and the value will be the value it is set to, including
623 * possibly null if the attribute is explicitly set to UNSPECIFIED using
624 * the ! sign. This will be invoked only once per attribute name, even if
625 * there are multiple rules for a given file. The highest priority rule
626 * will be used.
627 */
628 [CCode(cname = "git_attr_foreach")]
629 public Error for_each(AttrCheck flags, string path, AttributeForEach attribute_for_each);
630
631 /**
632 * Flush the gitattributes cache.
633 *
634 * Call this if you have reason to believe that the attributes files
635 * on disk no longer match the cached contents of memory. This will cause
636 * the attributes files to be reloaded the next time that an attribute
637 * access function is called.
638 */
639 [CCode(cname = "git_attr_cache_flush")]
640 public void flush();
641 }
642
643 /**
644 * In-memory representation of a blob object.
645 */
646 [CCode(cname = "git_blob", free_function = "git_blob_free", has_type_id = false)]
647 [Compact]
648 public class Blob : Object {
649 [CCode(array_length = false, cname = "git_blob_rawcontent")]
650 private unowned uint8[]? _get_content();
651
652 /**
653 * Get a read-only buffer with the raw content of a blob.
654 *
655 * A pointer to the raw content of a blob is returned.
656 * The pointer may be invalidated at a later time.
657 */
658 public uint8[]? content {
659 get {
660 unowned uint8[]? content = _get_content();
661 if (content != null) {
662 ((!)content).length = (int) size;
663 }
664 return content;
665 }
666 }
667 /**
668 * The id of a blob.
669 */
670 public object_id? id {
671 [CCode(cname = "git_blob_id")]
672 get;
673 }
674 /**
675 * Determine if the blob content is most certainly binary or not.
676 *
677 * The heuristic used to guess if a file is binary is taken from core git:
678 * Searching for NUL bytes and looking for a reasonable ratio of printable
679 * to non-printable characters among the first 4000 bytes.
680 */
681 public bool is_binary {
682 [CCode(cname = "git_blob_is_binary")]
683 get;
684 }
685
686 /**
687 * Get the size in bytes of the contents of a blob
688 */
689 public size_t size {
690 [CCode(cname = "git_blob_rawsize")]
691 get;
692 }
693 /**
694 * Directly run a text diff on two blobs.
695 *
696 * Compared to a file, a blob lacks some contextual information. As such, the
697 * {@link diff_file} parameters of the callbacks will be filled accordingly to the following:
698 * mode will be set to 0, path will be null. When dealing with a null blob, object id
699 * will be set to 0.
700 *
701 * When at least one of the blobs being dealt with is binary, the {@link diff_delta} binary
702 * attribute will be set to true and no call to the hunk nor line will be made.
703 *
704 * We do run a binary content check on the two blobs and if either of the
705 * blobs looks like binary data, {@link diff_delta.flags} will {@link DiffFlag.BINARY}
706 * and no call to the {@link DiffHunk} nor {@link DiffData} will be made
707 * (unless you pass {@link DiffFlags.FORCE_TEXT} of course).
708 */
709 [CCode(cname = "git_diff_blobs", simple_generics = true)]
710 public Error diff<T>(Blob new_blob, diff_options options, DiffFile<T> file, DiffHunk<T> hunk, DiffData<T> line, T context);
711 /**
712 * Directly run a diff between a blob and a buffer.
713 *
714 * As with {@link diff}, comparing a blob and buffer lacks some context, so
715 * the {@link diff_file} parameters to the callbacks will be faked.
716 */
717 [CCode(cname = "git_diff_blob_to_buffer", simple_generics = true)]
718 public Error diff_buffer<T>([CCode(array_length_type = "size_t")] uint8[] buffer, diff_options options, DiffFile<T> file, DiffHunk<T> hunk, DiffData<T> line, T context);
719 }
720
721 /**
722 * Parsed representation of a commit object.
723 */
724 [CCode(cname = "git_commit", free_function = "git_commit_free", has_type_id = false)]
725 [Compact]
726 public class Commit : Object {
727 /**
728 * The author of a commit.
729 */
730 public Signature author {
731 [CCode(cname = "git_commit_author")]
732 get;
733 }
734
735 /**
736 * The committer of a commit.
737 */
738 public Signature committer {
739 [CCode(cname = "git_commit_committer")]
740 get;
741 }
742
743 /**
744 * The id of a commit.
745 */
746 public object_id? id {
747 [CCode(cname = "git_commit_id")]
748 get;
749 }
750
751 /**
752 * The full message of a commit.
753 */
754 public string message {
755 [CCode(cname = "git_commit_message")]
756 get;
757 }
758
759 /**
760 * The encoding for the message of a commit, as a string representing a
761 * standard encoding name.
762 *
763 * The encoding may be null if the encoding header in the commit is
764 * missing; in that case UTF-8 is assumed.
765 */
766 public string? message_encoding {
767 [CCode(cname = "git_commit_message_encoding")]
768 get;
769 }
770
771 /**
772 * The parent(s) of this commit
773 *
774 * Typically, commits have a single parent, but merges can have many.
775 */
776 public Parents parents {
777 [CCode(cname = "")]
778 get;
779 }
780
781 /**
782 * Get the commit time (i.e., committer time) of a commit.
783 */
784 public int64 time {
785 [CCode(cname = "git_commit_time")]
786 get;
787 }
788
789 /**
790 * Get the commit timezone offset (i.e., committer's preferred timezone) in minutes from UTC of a commit.
791 */
792 public int time_offset {
793 [CCode(cname = "git_commit_time_offset")]
794 get;
795 }
796
797 /**
798 * Get the id of the tree pointed to by a commit.
799 *
800 * This differs from {@link lookup_tree} in that no attempts
801 * are made to fetch an object from the ODB.
802 */
803 public object_id? tree_id {
804 [CCode(cname = "git_commit_tree_oid")]
805 get;
806 }
807 /**
808 * Get the commit object that is an ancestor of the named commit object,
809 * following only the first parents.
810 *
811 * @param ancestor the ancestor received, if any
812 * @param n the requested generation, or 0 for a copy of the commit.
813 */
814 [CCode(cname = "git_commit_nth_gen_ancestor", instance_pos = 1.2)]
815 public Error get_ancestor(out Commit? ancestor, uint n);
816
817 /**
818 * The message of a commit converted to UTF-8.
819 */
820 public string? get_message_utf8() throws GLib.ConvertError {
821 return this.message_encoding == null ? this.message : GLib.convert(this.message, this.message.length, "utf-8", (!) this.message_encoding);
822 }
823
824 /**
825 * Get the tree pointed to by a commit.
826 */
827 [CCode(cname = "git_commit_tree", instance_pos = -1)]
828 public Error lookup_tree(out Tree tree);
829 }
830
831 /**
832 * Memory representation of a set of config files
833 */
834 [CCode(cname = "git_config", free_function = "git_config_free", has_type_id = false)]
835 [Compact]
836 public class Config {
837 /**
838 * Allocate a new configuration object
839 *
840 * This object is empty, so you have to add a file to it before you can do
841 * anything with it.
842 *
843 * @param config the new configuration
844 */
845 [CCode(cname = "git_config_new")]
846 public static Error create(out Config config);
847
848 /**
849 * Locate the path to the global configuration file
850 *
851 * The user or global configuration file is usually located in
852 * //$HOME/.gitconfig//.
853 *
854 * This method will try to guess the full path to that file, if the file
855 * exists. The returned path may be used on any call to load the global
856 * configuration file.
857 *
858 * @param config_path Buffer store the path
859 * @return {@link Error.OK} if a global configuration file has been found.
860 */
861 [CCode(cname = "git_config_find_global")]
862 public static Error find_global([CCode(array_length_type = "size_t")] char[] config_path);
863 /**
864 * Locate the path to the global xdg compatible configuration file
865 *
866 * The xdg compatible configuration file is usually located in
867 * //$HOME/.config/git/config//.
868 *
869 * This method will try to guess the full path to that file, if the file
870 * exists.
871 * @param config_path Buffer store the path
872 * @return {@link Error.OK} if an XDG configuration file has been found.
873 */
874 [CCode(cname = "git_config_find_xdg")]
875 public static Error find_xdg([CCode(array_length_type = "size_t")] char[] config_path);
876
877 /**
878 * Locate the path to the system configuration file
879 *
880 * If /etc/gitconfig doesn't exist, it will look for
881 * %PROGRAMFILES%\Git\etc\gitconfig.
882 * @param config_path Buffer of {@link PATH_MAX} length to store the path
883 * @return {@link Error.OK} if a system configuration file has been found. Its path will be stored in //buffer//.
884 */
885 [CCode(cname = "git_config_find_system")]
886 public static Error find_system([CCode(array_length_type = "size_t")] char[] config_path);
887
888
889 /**
890 * Maps a string value to an integer constant
891 */
892 [CCode(cname = "git_config_lookup_map_value")]
893 public static Error lookup_map_value(out int result, [CCode(array_length_type = "size_t")] config_var_map[] map, string name);
894
895 /**
896 * Create a new config instance containing a single on-disk file
897 *
898 * This method is a simple utility wrapper for the following sequence of
899 * calls:
900 * * {@link create}
901 * * {@link add_filename}
902 *
903 * @param cfg the configuration instance to create
904 * @param path path to the on-disk file to open
905 */
906 [CCode(cname = "git_config_open_ondisk")]
907 public static Error open(out Config? cfg, string path);
908
909 /**
910 * Open the global and system configuration files
911 *
912 * Utility wrapper that calls {@link find_global}, {@link find_xdg}, and
913 * {@link find_system} and opens the located file, if it exists.
914 *
915 * @param config where to store the config instance
916 */
917 [CCode(cname = "git_config_open_default")]
918 public static Error open_default(out Config? config);
919
920 /**
921 * Build a single-level focused config object from a multi-level one.
922 *
923 * The returned config object can be used to perform get/set/delete
924 * operations on a single specific level.
925 *
926 * Getting several times the same level from the same parent multi-level
927 * config will return different config instances, but containing the same
928 * config_file instance.
929 *
930 * @param parent Multi-level config to search for the given level
931 * @param level Configuration level to search for
932 */
933 [CCode(cname = "git_config_open_level")]
934 public static Error open_level(out Config? config, Config parent, ConfigLevel level);
935
936 /**
937 * Parse a string value as a bool.
938 *
939 * Valid values for true are: 'true', 'yes', 'on', 1 or any number
940 * different from 0
941 *
942 * Valid values for false are: 'false', 'no', 'off', 0
943 */
944 [CCode(cname = "git_config_parse_bool")]
945 public static Error bool(out bool result, string @value);
946
947 /**
948 * Parse a string value as an int32.
949 *
950 * An optional value suffix of 'k', 'm', or 'g' will cause the value to be
951 * multiplied by 1024, 1048576, or 1073741824 prior to output.
952 */
953 [CCode(cname = "git_config_parse_int32")]
954 public static Error parse_int32(out int32 result, string @value);
955
956 /**
957 * Parse a string value as an int64.
958 *
959 * An optional value suffix of 'k', 'm', or 'g' will cause the value to be
960 * multiplied by 1024, 1048576, or 1073741824 prior to output.
961 */
962 [CCode(cname = "git_config_parse_int64")]
963 public static Error parse_int64(out int64 result, string @value);
964
965 /**
966 * Add a generic config file instance to an existing config
967 *
968 * Further queries on this config object will access each of the config
969 * file instances in order (instances with a higher priority will be
970 * accessed first).
971 *
972 * @param backend the configuration file (backend) to add
973 * @param level the priority level of the backend
974 * @param force if a config file already exists for the given priority level, replace it
975 */
976 [CCode(cname = "git_config_add_backend")]
977 public Error add_backend(Configuration.backend backend, ConfigLevel level, bool force);
978
979 /**
980 * Add an on-disk config file instance to an existing config
981 *
982 * The on-disk file pointed at by path will be opened and parsed; it's
983 * expected to be a native Git config file following the default Git config
984 * syntax (see man git-config).
985 *
986 * Further queries on this config object will access each of the config
987 * file instances in order (instances with a higher priority will be
988 * accessed first).
989 *
990 * @param path path to the configuration file (backend) to add
991 * @param level the priority the backend should have
992 */
993 [CCode(cname = "git_config_add_file_ondisk")]
994 public Error add_filename(string path, ConfigLevel level, bool force);
995
996 /**
997 * Delete a config variable
998 *
999 * @param name the variable to delete
1000 */
1001 [CCode(cname = "git_config_delete_entry")]
1002 public Error delete(string name);
1003
1004 /**
1005 * Perform an operation on each config variable.
1006 *
1007 * The callback receives the normalized name and value of each variable in
1008 * the config backend. As soon as one of the callback functions returns
1009 * something other than 0, this function returns that value.
1010 *
1011 * @param config_for_each the function to call on each variable
1012 */
1013 [CCode(cname = "git_config_foreach")]
1014 public int for_each(ConfigForEach config_for_each);
1015 /**
1016 * Perform an operation on each config variable matching a regular expression.
1017 *
1018 * This behaviors like {@link for_each} with an additional filter of a
1019 * regular expression that filters which config keys are passed to the
1020 * callback.
1021 *
1022 * @param regexp regular expression to match against config names
1023 * @param config_for_each the function to call on each variable
1024 * @return 0 or the return value of the callback which didn't return 0
1025 */
1026 [CCode(cname = "git_config_foreach_match")]
1027 public int for_each_match(string regexp, ConfigForEach config_for_each);
1028
1029 /**
1030 * Get the value of a boolean config variable.
1031 *
1032 * @param name the variable's name
1033 * @param value where the value should be stored
1034 */
1035 [CCode(cname = "git_config_get_bool")]
1036 public Error get_bool(string name, out bool value);
1037
1038 /**
1039 * Get the entry of a config variable.
1040 * @param name the variable's name
1041 */
1042 [CCode(cname = "git_config_get_entry", instance_pos = 1.1)]
1043 public Error get_entry(out unowned config_entry? entry, string name);
1044
1045 /**
1046 * Get the value of an integer config variable.
1047 *
1048 * @param name the variable's name
1049 * @param value where the value should be stored
1050 */
1051 [CCode(cname = "git_config_get_int")]
1052 public Error get_int32(string name, out int32 value);
1053
1054 /**
1055 * Get the value of a long integer config variable.
1056 *
1057 * @param name the variable's name
1058 * @param value where the value should be stored
1059 */
1060 [CCode(cname = "git_config_get_int64")]
1061 public Error get_int64(string name, out int64 value);
1062
1063 /**
1064 * Get each value of a multivar.
1065 *
1066 * The callback will be called on each variable found
1067 *
1068 * @param name the variable's name
1069 * @param regexp regular expression to filter which variables we're interested in. Use NULL to indicate all
1070 * @param fn the function to be called on each value of the variable
1071 */
1072 [CCode(cname = "git_config_get_multivar")]
1073 public Error get_multivar(string name, string? regexp, Configuration.Setter fn);
1074
1075 /**
1076 * Get the value of a string config variable.
1077 *
1078 * @param name the variable's name
1079 * @param value the variable's value
1080 */
1081 public Error get_string(string name, out unowned string value);
1082
1083 /**
1084 * Reload changed config files
1085 *
1086 * A config file may be changed on disk out from under the in-memory config
1087 * object. This function causes us to look for files that have been
1088 * modified since we last loaded them and refresh the config with the
1089 * latest information.
1090 */
1091 [CCode(cname = "git_config_refresh")]
1092 public Error refresh();
1093 /**
1094 * Set the value of a boolean config variable.
1095 *
1096 * @param name the variable's name
1097 * @param value the value to store
1098 */
1099 [CCode(cname = "git_config_set_bool")]
1100 public Error set_bool(string name, bool value);
1101
1102 /**
1103 * Set the value of an integer config variable.
1104 *
1105 * @param name the variable's name
1106 * @param value integer value for the variable
1107 */
1108 [CCode(cname = "git_config_set_int32")]
1109 public Error set_int32(string name, int32 value);
1110
1111 /**
1112 * Set the value of a long integer config variable.
1113 *
1114 * @param name the variable's name
1115 * @param value Long integer value for the variable
1116 */
1117 [CCode(cname = "git_config_set_long64")]
1118 public Error set_int64(string name, int64 value);
1119
1120 /**
1121 * Set a multivar
1122 *
1123 * @param name the variable's name
1124 * @param regexp a regular expression to indicate which values to replace
1125 * @param value the new value.
1126 */
1127 [CCode(cname = "git_config_set_multivar")]
1128 public Error set_multivar(string name, string regexp, string @value);
1129 /**
1130 * Set the value of a string config variable.
1131 *
1132 * A copy of the string is made and the user is free to use it
1133 * afterwards.
1134 *
1135 * @param name the variable's name
1136 * @param value the string to store.
1137 */
1138 [CCode(cname = "git_config_set_string")]
1139 public Error set_string(string name, string value);
1140 /**
1141 * Query the value of a config variable and return it mapped to an integer
1142 * constant.
1143 *
1144 * This is a helper method to easily map different possible values to a
1145 * variable to integer constants that easily identify them.
1146 *
1147 * A mapping array looks as follows:
1148 * {{{
1149 * var autocrlf_mapping = Git.config_var_map[] {
1150 * {Git.ConfigVar.FALSE, null, GIT_AUTO_CRLF_FALSE},
1151 * {Git.ConfigVar.TRUE, null, GIT_AUTO_CRLF_TRUE},
1152 * {Git.ConfigVar.STRING, "input", GIT_AUTO_CRLF_INPUT},
1153 * {Git.ConfigVar.STRING, "default", GIT_AUTO_CRLF_DEFAULT}};
1154 * }}}
1155 *
1156 * On any "false" value for the variable (e.g. "false", "FALSE", "no"), the
1157 * mapping will store `GIT_AUTO_CRLF_FALSE` in the `out` parameter.
1158 *
1159 * The same thing applies for any "true" value such as "true", "yes" or "1", storing
1160 * the `GIT_AUTO_CRLF_TRUE` variable.
1161 *
1162 * Otherwise, if the value matches the string "input" (with case insensitive comparison),
1163 * the given constant will be stored in `out`, and likewise for "default".
1164 *
1165 * If not a single match can be made to store in `out`, an error code will be
1166 * returned.
1167 *
1168 * @param name name of the config variable to lookup
1169 * @param map array of objects specifying the possible mappings
1170 * @param result place to store the result of the mapping
1171 */
1172 [CCode(cname = "git_config_get_mapped", instance_pos = 1.1)]
1173 public Error get_mapped(out int result, string name, [CCode(array_length_type = "size_t")] config_var_map[] map);
1174
1175 }
1176 /**
1177 * The diff list object that contains all individual file deltas.
1178 */
1179 [CCode(cname = "git_diff_list", free_function = "git_diff_list_free")]
1180 [Compact]
1181 public class DiffList {
1182 /**
1183 * How many diff records are there in a diff list.
1184 */
1185 public size_t num_deltas {
1186 [CCode(cname = "git_diff_num_deltas")]
1187 get;
1188 }
1189 /**
1190 * Query how many diff records are there in a diff list.
1191 * @param delta_t A delta type to filter the count, or -1 for all records
1192 * @return Count of number of deltas matching delta_t type
1193 */
1194 [CCode(cname = "git_diff_num_deltas_of_type")]
1195 public size_t get_count(DeltaType delta_t = DeltaType.ALL);
1196 /**
1197 * Return the diff delta and patch for an entry in the diff list.
1198 *
1199 * For an unchanged file or a binary file, no patch will be created, and
1200 * the {@link diff_delta.flags} will contain {@link DiffFlag.BINARY}.
1201 *
1202 * @param patch contains the text diffs for the delta.
1203 * @param delta Output parameter for the delta object
1204 * @param idx Index into diff list
1205 */
1206 [CCode(cname = "git_diff_get_patch", instance_pos = 2.1)]
1207 public Error get_patch(out Patch? patch, out unowned diff_delta? delta, size_t idx);
1208 /**
1209 * Merge one diff list into another.
1210 *
1211 * This merges items from the "from" list into the current list. The
1212 * resulting diff list will have all items that appear in either list.
1213 * If an item appears in both lists, then it will be "merged" to appear
1214 * as if the old version was from the "onto" list and the new version
1215 * is from the "from" list (with the exception that if the item has a
1216 * pending DELETE in the middle, then it will show as deleted).
1217 *
1218 * @param from Diff to merge.
1219 */
1220 [CCode(cname = "git_diff_merge")]
1221 public Error merge(DiffList from);
1222
1223 /**
1224 * Iterate over a diff list issuing callbacks.
1225 *
1226 * If the hunk and/or line callbacks are not null, then this will calculate
1227 * text diffs for all files it thinks are not binary. If those are both
1228 * null, then this will not bother with the text diffs, so it can be
1229 * efficient.
1230 */
1231 [CCode(cname = "git_diff_foreach", simple_generics = true)]
1232 public Error foreach<T>(DiffFile<T>? file, DiffHunk<T> hunk, DiffLine<T>? line, T context);
1233
1234 /**
1235 * Iterate over a diff generating text output like "git diff --name-status".
1236 */
1237 [CCode(cname = "git_diff_print_compact")]
1238 public Error print_compact(DiffOutput print);
1239
1240 /**
1241 * Iterate over a diff generating text output like "git diff".
1242 *
1243 * This is a super easy way to generate a patch from a diff.
1244 */
1245 [CCode(cname = "git_diff_print_patch")]
1246 public Error print_patch(DiffOutput print);
1247 /**
1248 * Transform a diff list marking file renames, copies, etc.
1249 *
1250 * This modifies a diff list in place, replacing old entries that look like
1251 * renames or copies with new entries reflecting those changes. This also
1252 * will, if requested, break modified files into add/remove pairs if the
1253 * amount of change is above a threshold.
1254 *
1255 * @param options Control how detection should be run, null for defaults
1256 */
1257 [CCode(cname = "git_diff_find_similar")]
1258 public Error find_similar(find_options? options = null);
1259 }
1260
1261 [CCode(cname = "git_error", has_type_id = false, free_function = "")]
1262 public class ErrorInfo {
1263 /**
1264 * The explanation of the error.
1265 */
1266 public string message;
1267 /**
1268 * The error code.
1269 */
1270 [CCode(cname = "klass")]
1271 public ErrClass @class;
1272 /**
1273 * Return a detailed error string with the latest error
1274 * that occurred in the library in this thread.
1275 */
1276 [CCode(cname = "giterr_last")]
1277 public static unowned ErrorInfo? get_last();
1278
1279 /**
1280 * Clear the last library error for this thread.
1281 */
1282 [CCode(cname = "giterr_clear")]
1283 public static void clear();
1284 }
1285
1286
1287 /**
1288 * Object ID Shortener object
1289 */
1290 [CCode(cname = "git_oid_shorten", free_function = "git_oid_shorten_free", has_type_id = false)]
1291 [Compact]
1292 public class IdShortener {
1293 /**
1294 * Create a new id shortener.
1295 *
1296 * The id shortener is used to process a list of ids in text form and
1297 * return the shortest length that would uniquely identify all of them.
1298 *
1299 * (e.g., look at the result of //git log --abbrev//)
1300 *
1301 * @param min_length The minimal length for all identifiers, which will be used even if shorter ids would still be unique.
1302 */
1303 [CCode(cname = "git_oid_shorten_new")]
1304 public IdShortener(size_t min_length);
1305
1306 /**
1307 * Add a new id to set of shortened ids and calculate the minimal length to
1308 * uniquely identify all the ids in the set.
1309 *
1310 * The id is expected to be a 40-char hexadecimal string.
1311 *
1312 * For performance reasons, there is a hard-limit of how many ids can be
1313 * added to a single set (around ~22000, assuming a mostly randomized
1314 * distribution), which should be enough for any kind of program, and keeps
1315 * the algorithm fast and memory-efficient.
1316 *
1317 * Attempting to add more than those ids will result in a {@link ErrClass.NOMEMORY} error
1318 *
1319 * @param text_id an id in text form
1320 * @return the minimal length to uniquely identify all ids added so far to the set; or an error code (<0) if an error occurs.
1321 */
1322 [CCode(cname = "git_oid_shorten_add")]
1323 public int add(string text_id);
1324 }
1325
1326 /**
1327 * Memory representation of an index file.
1328 */
1329 [CCode(cname = "git_index", free_function = "git_index_free", has_type_id = false)]
1330 [Compact]
1331 public class Index {
1332 /**
1333 * Index capabilities flags.
1334 */
1335 public IndexCapability capability {
1336 [CCode(cname = "git_index_caps")]
1337 get;
1338 [CCode(cname = "git_index_set_caps")]
1339 set;
1340 }
1341
1342 /**
1343 * Does the index contains entries representing file conflicts?
1344 */
1345 public bool has_conflicts {
1346 [CCode(cname = "git_index_has_conflicts")]
1347 get;
1348 }
1349
1350 public ReucIndex reuc {
1351 [CCode(cname = "")]
1352 get;
1353 }
1354
1355 /**
1356 * The repository this index relates to
1357 */
1358 public Repository owner {
1359 [CCode(cname = "git_index_owner")]
1360 get;
1361 }
1362
1363 /**
1364 * The count of entries currently in the index
1365 */
1366 public uint size {
1367 [CCode(cname = "git_index_entrycount")]
1368 get;
1369 }
1370
1371 /**
1372 * Create an in-memory index object.
1373 *
1374 * This index object cannot be read/written to the filesystem,
1375 * but may be used to perform in-memory index operations.
1376 *
1377 * The index must be freed once it's no longer in use.
1378 */
1379 [CCode(cname = "git_index_new")]
1380 public static Error create(out Index? index);
1381 /**
1382 * Create a new bare Git index object as a memory representation of the Git
1383 * index file in the index path, without a repository to back it.
1384 *
1385 * Since there is no ODB or working directory behind this index, any index
1386 * methods which rely on these (e.g., {@link add}) will fail.
1387 *
1388 * If you need to access the index of an actual repository, use {@link Repository.get_index}.
1389 *
1390 * @param index where to put the new index
1391 * @param index_path the path to the index file in disk
1392 */
1393 public static Error open(out Index index, string index_path);
1394
1395 /**
1396 * Add or update an index entry from an in-memory struct
1397 *
1398 * A full copy (including the path string) of the given source will be
1399 * inserted on the index.
1400 *
1401 * @param entry new entry object
1402 */
1403 [CCode(cname = "git_index_add")]
1404 public Error add(IndexEntry entry);
1405
1406 /**
1407 * Add (append) an index entry from a file on disk
1408 *
1409 * A new entry will always be inserted into the index; if the index already
1410 * contains an entry for such path, the old entry will ''not'' be replaced.
1411 *
1412 * The file path must be relative to the repository's working folder and
1413 * must be readable.
1414 *
1415 * This method will fail in bare index instances.
1416 *
1417 * This forces the file to be added to the index, not looking at gitignore
1418 * rules.
1419 *
1420 * If this file currently is the result of a merge conflict, this file will
1421 * no longer be marked as conflicting. The data about the conflict will be
1422 * moved to the "resolve undo" (REUC) section.
1423 *
1424 * @param path filename to add
1425 */
1426 [CCode(cname = "git_index_add_bypath")]
1427 public Error add_path(string path);
1428
1429 /**
1430 * Clear the contents (all the entries) of an index object.
1431 *
1432 * This clears the index object in memory; changes must be manually written
1433 * to disk for them to take effect.
1434 */
1435 [CCode(cname = "git_index_clear")]
1436 public void clear();
1437
1438 /**
1439 * Add or update index entries to represent a conflict
1440 *
1441 * The entries are the entries from the tree included in the merge. Any
1442 * entry may be null to indicate that that file was not present in the
1443 * trees during the merge. For example, the ancestor entry may be null to
1444 * indicate that a file was added in both branches and must be resolved.
1445 *
1446 * @param ancestor_entry the entry data for the ancestor of the conflict
1447 * @param our_entry the entry data for our side of the merge conflict
1448 * @param their_entry the entry data for their side of the merge conflict
1449 */
1450 [CCode(cname = "git_index_conflict_add")]
1451 public Error conflict_add(IndexEntry? ancestor_entry, IndexEntry? our_entry, IndexEntry? their_entry);
1452
1453 /**
1454 * Get the index entries that represent a conflict of a single file.
1455 *
1456 * The values of this entry can be modified (except the paths)
1457 * and the changes will be written back to disk on the next
1458 * write() call.
1459 *
1460 * @param ancestor Pointer to store the ancestor entry
1461 * @param our Pointer to store the our entry
1462 * @param their Pointer to store the their entry
1463 * @param path path to search
1464 */
1465 [CCode(cname = "git_index_conflict_get", instance_pos = 3.1)]
1466 public Error conflict_get(out unowned IndexEntry? ancestor, out unowned IndexEntry? our, out unowned IndexEntry? their, string path);
1467
1468 /**
1469 * Remove all conflicts in the index (entries with a stage greater than 0.)
1470 */
1471 [CCode(cname = "git_index_conflict_cleanup")]
1472 public void conflict_cleanup();
1473 /**
1474 * Removes the index entries that represent a conflict of a single file.
1475 *
1476 * @param path to search
1477 */
1478 [CCode(cname = "git_index_conflict_remove")]
1479 public Error conflict_remove(string path);
1480
1481 /**
1482 * Find the first index of any entries which point to given path in the Git
1483 * index.
1484 *
1485 * @param at_pos the address to which the position of the reuc entry is written (optional)
1486 * @param path path to search
1487 */
1488 [CCode(cname = "git_index_find", instance_pos = 1.1)]
1489 public Error find(out size_t at_pos, string path);
1490
1491 /**
1492 * Get a pointer to one of the entries in the index
1493 *
1494 * This entry can be modified, and the changes will be written back to disk
1495 * on the next {@link write} call.
1496 *
1497 * @param n the position of the entry
1498 * @return the entry; null if out of bounds
1499 */
1500 [CCode(cname = "git_index_get_byindex")]
1501 public unowned IndexEntry? get(size_t n);
1502
1503 /**
1504 * Get a pointer to one of the entries in the index
1505 *
1506 * The values of this entry can be modified (except the path) and the
1507 * changes will be written back to disk on the next {@link write} call.
1508 *
1509 * @param path path to search
1510 * @param stage stage to search
1511 */
1512 [CCode(cname = "git_index_get_bypath")]
1513 public unowned IndexEntry? get_by_path(string path, int stage);
1514
1515 /**
1516 * Remove all entries with equal path except last added
1517 */
1518 [CCode(cname = "git_index_uniq")]
1519 public void make_unique();
1520
1521 /**
1522 * Update the contents of an existing index object in memory by reading
1523 * from the hard disk.
1524 */
1525 [CCode(cname = "git_index_read")]
1526 public Error read();
1527
1528 /**
1529 * Read a tree into the index file with stats
1530 *
1531 * The current index contents will be replaced by the specified tree.
1532 *
1533 * @param tree tree to read
1534 */
1535 [CCode(cname = "git_index_read_tree")]
1536 public Error read_tree(Tree tree);
1537
1538 /**
1539 * Remove an entry from the index
1540 */
1541 [CCode(cname = "git_index_remove")]
1542 public Error remove(string path, int stage);
1543 /**
1544 * Remove all entries from the index under a given directory
1545 *
1546 * @param dir container directory path
1547 * @param stage stage to search
1548 */
1549 [CCode(cname = "git_index_remove_directory")]
1550 public Error remove_directory(string dir, int stage);
1551
1552 /**
1553 * Remove an index entry corresponding to a file on disk
1554 *
1555 * The file path must be relative to the repository's working folder. It
1556 * may exist.
1557 *
1558 * If this file currently is the result of a merge conflict, this file will
1559 * no longer be marked as conflicting. The data about the conflict will be
1560 * moved to the "resolve undo" (REUC) section.
1561 *
1562 * @param path filename to remove
1563 */
1564 [CCode(cname = "git_index_remove_bypath")]
1565 public Error remove_path(string path);
1566
1567 /**
1568 * Write an existing index object from memory back to disk using an atomic
1569 * file lock.
1570 */
1571 [CCode(cname = "git_index_write")]
1572 public Error write();
1573
1574 /**
1575 * Write the index as a tree
1576 *
1577 * This method will scan the index and write a representation of its
1578 * current state back to disk; it recursively creates
1579 * tree objects for each of the subtrees stored in the index, but only
1580 * returns the OID of the root tree. This is the OID that can be used e.g.
1581 * to create a commit.
1582 *
1583 * The index instance cannot be bare, and needs to be associated to an
1584 * existing repository.
1585 *
1586 * The index must not contain any file in conflict.
1587 */
1588 [CCode(cname = "git_index_write_tree", instance_pos = -1)]
1589 public Error write_tree(out object_id id);
1590
1591 /**
1592 * Write the index as a tree to the given repository
1593 *
1594 * This method will do the same as {@link write_tree}, but letting the user
1595 * choose the repository where the tree will be written.
1596 *
1597 * The index must not contain any file in conflict.
1598 *
1599 * @param id Pointer where to store OID of the the written tree
1600 * @param repo Repository where to write the tree
1601 */
1602 [CCode(cname = "git_index_write_tree_to", instance_pos = 1.1)]
1603 public Error write_tree_to(out object_id id, Repository repo);
1604
1605 }
1606
1607 [CCode(cname = "git_indexer_stream", free_function = "git_indexer_stream_free", has_type_id = false)]
1608 public class IndexerStream {
1609 /**
1610 * The packfile's hash
1611 *
1612 * A packfile's name is derived from the sorted hashing of all object
1613 * names. This is only correct after the index has been finalized.
1614 */
1615 public object_id? hash {
1616 [CCode(cname = "git_indexer_stream_hash")]
1617 get;
1618 }
1619 /**
1620 * Create a new streaming indexer instance
1621 *
1622 * @param indexer_stream where to store the indexer instance
1623 * @param path to the directory where the packfile should be stored
1624 */
1625 [CCode(cname = "git_indexer_stream_new")]
1626 public static Error open(out IndexerStream indexer_stream, string path, TransferProgress transfer);
1627
1628 /**
1629 * Add data to the indexer
1630 *
1631 * @param data the data to add
1632 * @param stats stat storage
1633 */
1634 [CCode(cname = "git_indexer_stream_add")]
1635 public Error add([CCode(array_length_type = "size_t")] uint8[] data, transfer_progress stats);
1636
1637 /**
1638 * Finalize the pack and index
1639 *
1640 * Resolve any pending deltas and write out the index file
1641 */
1642 [CCode(cname = "git_indexer_stream_finalize")]
1643 public Error finalize(transfer_progress stats);
1644 }
1645
1646 /**
1647 * Memory representation of a file entry in the index.
1648 */
1649 [CCode(cname = "git_index_entry", has_type_id = false)]
1650 [Compact]
1651 public class IndexEntry {
1652 public Attributes flags;
1653 public index_time ctime;
1654 public index_time mtime;
1655 public int64 file_size;
1656 [CCode(cname = "oid")]
1657 public object_id id;
1658 public string path;
1659 public uint16 flags_extended;
1660 public uint dev;
1661 public uint gid;
1662 public uint ino;
1663 public uint mode;
1664 public uint uid;
1665
1666 /**
1667 * The stage number from a git index entry
1668 */
1669 public int stage {
1670 [CCode(cname = "git_index_entry_stage")]
1671 get;
1672 }
1673 }
1674 /**
1675 * A note attached to an object
1676 */
1677 [CCode(cname = "git_note", free_function = "git_note_free", has_type_id = false)]
1678 [Compact]
1679 public class Note {
1680 /**
1681 * The message for this note
1682 */
1683 public string message {
1684 [CCode(cname = "git_note_message")]
1685 get;
1686 }
1687
1688 /**
1689 * The note object OID
1690 */
1691 public object_id? id {
1692 [CCode(cname = "git_note_oid")]
1693 get;
1694 }
1695 }
1696 [CCode(cname = "git_note_iterator ", free_function = "git_note_iterator_free", has_type_id = false)]
1697 [Compact]
1698 public class NoteIterator {
1699 /**
1700 * Returns the current item and advance the iterator internally to the next
1701 * value.
1702 */
1703 [CCode(cname = "git_note_next", instance_pos = -1)]
1704 public Error next(out object_id note_id, out object_id annotated_id);
1705 }
1706 /**
1707 * Representation of a generic object in a repository
1708 */
1709 [CCode(cname = "git_object", free_function = "git_object_free", has_type_id = false)]
1710 [Compact]
1711 public class Object {
1712 /**
1713 * The id (SHA1) of a repository object
1714 */
1715 public object_id? id {
1716 [CCode(cname = "git_object_id")]
1717 get;
1718 }
1719
1720 /**
1721 * The object type of an object
1722 */
1723 public ObjectType type {
1724 [CCode(cname = "git_object_type")]
1725 get;
1726 }
1727
1728 /**
1729 * The repository that owns this object
1730 */
1731 public Repository repository {
1732 [CCode(cname = "git_object_owner")]
1733 get;
1734 }
1735 /**
1736 * Recursively peel an object until an object of the specified type is met
1737 *
1738 * @param target_type The type of the requested object
1739 */
1740 [CCode(cname = "git_object_peel", instance_pos = 1.1)]
1741 public Error peel(out Object? peeled, ObjectType target_type);
1742 }
1743
1744 [Compact]
1745 [CCode(cname = "git_packbuilder", free_function = "git_packbuilder_free", has_type_id = false)]
1746 public class PackBuilder {
1747
1748 /**
1749 * The total number of objects the packbuilder will write out
1750 */
1751 public uint32 count {
1752 [CCode(cname = "packbuilder_object_count")]
1753 get;
1754 }
1755 /**
1756 * The number of objects the packbuilder has already written out
1757 */
1758 public uint32 written {
1759 [CCode(cname = "git_packbuilder_written")]
1760 get;
1761 }
1762
1763 /**
1764 * Set number of threads to spawn
1765 *
1766 * By default, libgit2 won't spawn any threads at all; when set to 0,
1767 * libgit2 will autodetect the number of CPUs.
1768 *
1769 * @param n Number of threads to spawn
1770 * @return number of actual threads to be used
1771 */
1772 [CCode(cname = "git_packbuilder_set_threads")]
1773 public uint set_threads(uint n);
1774
1775 /**
1776 * Insert a single object
1777 *
1778 * For an optimal pack it's mandatory to insert objects in recency order,
1779 * commits followed by trees and blobs.
1780 *
1781 * @param id The oid of the commit
1782 * @param name The name
1783 */
1784 [CCode(cname = "git_packbuilder_insert")]
1785 public Error insert(object_id id, string? name);
1786 /**
1787 * Insert a root tree object
1788 *
1789 * This will add the tree as well as all referenced trees and blobs.
1790 *
1791 * @param id The oid of the root tree
1792 */
1793 [CCode(cname = "git_packbuilder_insert_tree")]
1794 public Error insert_tree(object_id id);
1795
1796 /**
1797 * Write the new pack and the corresponding index to path
1798 *
1799 * @param path Directory to store the new pack and index
1800 */
1801 [CCode(cname = "git_packbuilder_write")]
1802 public Error write(string path);
1803
1804 /**
1805 * Create the new pack and pass each object to the callback
1806 */
1807 [CCode(cname = "git_packbuilder_foreach")]
1808 public Error for_each(PackBuilderForEach pack_builder_for_each);
1809 }
1810 /**
1811 * The list of parents of a commit
1812 */
1813 [Compact]
1814 [CCode(cname = "git_commit", has_type_id = false)]
1815 public class Parents {
1816 /**
1817 * Get the number of parents of this commit
1818 */
1819 public uint size {
1820 [CCode(cname = "git_commit_parentcount")]
1821 get;
1822 }
1823
1824 /**
1825 * Get the id of a specified parent for a commit.
1826 *
1827 * This is different from {@link Parents.lookup}, which will attempt
1828 * to load the parent commit from the ODB.
1829 *
1830 * @param n the position of the parent
1831 * @return the id of the parent, null on error.
1832 */
1833 [CCode(cname = "git_commit_parent_id")]
1834 public unowned object_id? get(uint n);
1835
1836 /**
1837 * Get the specified parent of the commit.
1838 *
1839 * @param parent where to store the parent commit
1840 * @param n the position of the parent
1841 */
1842 [CCode(cname = "git_commit_parent", instance_pos = 1.2)]
1843 public Error lookup(out Commit parent, uint n);
1844 }
1845 [CCode(cname = "git_diff_patch ", free_function = "git_diff_patch_free", has_type_id = false)]
1846 [Compact]
1847 public class Patch {
1848 /**
1849 * The delta associated with a patch
1850 */
1851 public diff_delta? delta {
1852 [CCode(cname = "git_diff_patch_delta")]
1853 get;
1854 }
1855 /**
1856 * The number of hunks in a patch
1857 */
1858 public size_t num_hunks {
1859 [CCode(cname = "git_diff_patch_num_hunks")]
1860 get;
1861 }
1862 /**
1863 * Get the information about a hunk in a patch
1864 *
1865 * Given a patch and a hunk index into the patch, this returns detailed
1866 * information about that hunk. Any of the output pointers can be passed
1867 * as NULL if you don't care about that particular piece of information.
1868 *
1869 * @param range Range of the hunk
1870 * @param header Header string for hunk. Unlike the content for each line,
1871 * this will be NUL-terminated
1872 * @param lines_in_hunk Count of total lines in this hunk
1873 * @param hunk_idx Input index of hunk to get information about
1874 */
1875 [CCode(cname = "git_diff_patch_get_hunk", instance_pos = 3.1)]
1876 public Error get_hunk(out unowned diff_range? range, [CCode(array_length_type = "size_t")] out unowned uint8[]? header, out size_t lines_in_hunk, size_t hunk_idx);
1877 /**
1878 * Get data about a line in a hunk of a patch.
1879 *
1880 * Given a patch, a hunk index, and a line index in the hunk, this will
1881 * return a lot of details about that line. If you pass a hunk index
1882 * larger than the number of hunks or a line index larger than the number
1883 * of lines in the hunk, this will return -1.
1884 *
1885 * @param old_lineno Line number in old file or -1 if line is added
1886 * @param new_lineno Line number in new file or -1 if line is deleted
1887 * @param hunk_idx The index of the hunk
1888 * @param line_of_hunk The index of the line in the hunk
1889 */
1890 [CCode(cname = "git_diff_patch_get_line_in_hunk", instance_pos = 4.1)]
1891 public Error get_line_in_hunk(out DiffLineType line_origin, [CCode(array_length_type = "size_t")] out unowned uint8[]? content, out int old_lineno, out int new_lineno, size_t hunk_idx, size_t line_of_hunk);
1892 /**
1893 * Get line counts of each type in a patch.
1894 *
1895 * This helps imitate a '''diff --numstat''' type of output. For that
1896 * purpose, you only need the total additions and total_deletions values,
1897 * but we include the total context line count in case you want the total
1898 * number of lines of diff output that will be generated.
1899 *
1900 * @param total_context Count of context lines in output.
1901 * @param total_additions Count of addition lines in output.
1902 * @param total_deletions Count of deletion lines in output.
1903 * @return Number of lines in hunk or -1 if invalid hunk index
1904 */
1905 [CCode(cname = "git_diff_patch_line_stats", instance_pos = -1)]
1906 public int get_line_stats(out size_t total_context, out size_t total_additions, out size_t total_deletions);
1907
1908 /**
1909 * Get the number of lines in a hunk.
1910 *
1911 * @param hunk_idx Index of the hunk
1912 * @return Number of lines in hunk or -1 if invalid hunk index
1913 */
1914 [CCode(cname = "git_diff_patch_num_lines_in_hunk")]
1915 public int num_lines_in_hunk(size_t hunk_idx);
1916
1917 /**
1918 * Serialize the patch to text via callback.
1919 */
1920 [CCode(cname = "git_diff_patch_print")]
1921 public Error patch_print(DiffOutput print);
1922
1923 /**
1924 * Get the content of a patch as a single diff text.
1925 */
1926 [CCode(cname = "git_diff_patch_to_str", instance_pos = -1)]
1927 public Error to_str(out string str);
1928
1929 public string? to_string() {
1930 string? str;
1931 return to_str(out str) == Error.OK ? str : null;
1932 }
1933 }
1934 [Compact]
1935 [CCode(cname = "git_push", free_function = "git_push_free", has_type_id = false)]
1936 public class Push {
1937 /**
1938 * Check if remote side successfully unpacked
1939 */
1940 public bool unpack_ok {
1941 [CCode(cname = "git_push_unpack_ok")]
1942 get;
1943 }
1944
1945 /**
1946 * Add a refspec to be pushed
1947 */
1948 [CCode(cname = "git_push_add_refspec")]
1949 public Error add_refspec(string refspec);
1950
1951 /**
1952 * Actually push all given refspecs
1953 *
1954 * To check if the push was successful (i.e. all remote references have
1955 * been updated as requested), you need to call both {@link unpack_ok} and
1956 * {@link for_each}. The remote repository might have refused to update
1957 * some or all of the references.
1958 */
1959 [CCode(cname = "git_push_finish")]
1960 public Error finish();
1961 /**
1962 * Iterate over each status.
1963 *
1964 * For each of the updated references, we receive a status report in the
1965 * form of '''ok refs/heads/master''' or '''ng refs/heads/master ///msg///'''.
1966 * If the message is not null, this means the reference has not been
1967 * updated for the given reason.
1968 *
1969 */
1970 [CCode(cname = "git_push_status_foreach")]
1971 public Error for_each(PushForEach push_for_each);
1972 /**
1973 * Set options on a push object
1974 *
1975 * @param opts The options to set on the push object
1976 */
1977 [CCode(cname = "git_push_set_options")]
1978 public Error set_options(push_options opts);
1979 /**
1980 * Update remote tips after a push
1981 */
1982 [CCode(cname = "git_push_update_tips")]
1983 public Error update_tips();
1984 }
1985 [CCode(cname = "git_refdb", has_type_id = false, free_function = "git_refdb_free")]
1986 public class RefDb {
1987 /**
1988 * Create a new reference. Either an oid or a symbolic target must be
1989 * specified.
1990 *
1991 * @param name the reference name
1992 * @param id the object id for a direct reference
1993 * @param symbolic the target for a symbolic reference
1994 */
1995 [CCode(cname = "git_reference__alloc")]
1996 public Reference? alloc(string name, object_id id, string symbolic);
1997
1998 /**
1999 * Suggests that the given refdb compress or optimize its references.
2000 *
2001 * This mechanism is implementation specific. For on-disk reference
2002 * databases, for example, this may pack all loose references.
2003 */
2004 [CCode(cname = "git_refdb_compress")]
2005 public Error compress();
2006
2007 /**
2008 * Sets the custom backend to an existing reference DB
2009 */
2010 [CCode(cname = "git_refdb_set_backend")]
2011 public Error set_backend(owned refdb_backend backend);
2012 }
2013 /**
2014 * In-memory representation of a reference.
2015 */
2016 [CCode(cname = "git_reference", free_function = "git_reference_free", has_type_id = false)]
2017 [Compact]
2018 public class Reference {
2019 /**
2020 * Check if a reflog exists for the specified reference.
2021 */
2022 public bool has_log {
2023 [CCode(cname = "git_reference_has_log")]
2024 get;
2025 }
2026 /**
2027 * Check if a reference is a local branch.
2028 */
2029 public bool is_branch {
2030 [CCode(cname = "git_reference_is_branch")]
2031 get;
2032 }
2033
2034 /**
2035 * Determine if the current local branch is pointed at by HEAD.
2036 */
2037 public bool is_head {
2038 [CCode(cname = "0 != git_branch_is_head")]
2039 get;
2040 }
2041
2042 /**
2043 * If a reference is a remote tracking branch
2044 */
2045 public bool is_remote {
2046 [CCode(cname = "git_reference_is_remote")]
2047 get;
2048 }
2049
2050 /**
2051 * The full name of a reference
2052 */
2053 public string name {
2054 [CCode(cname = "git_reference_name")]
2055 get;
2056 }
2057
2058 /**
2059 * The repository where a reference resides
2060 */
2061 public Repository repository {
2062 [CCode(cname = "git_reference_owner")]
2063 get;
2064 }
2065
2066 /**
2067 * The full name to the reference pointed by this reference
2068 *
2069 * Only available if the reference is symbolic
2070 */
2071 public string? symbolic_target {
2072 [CCode(cname = "git_reference_symbolic_target")]
2073 get;
2074 }
2075
2076 /**
2077 * The id pointed to by a reference.
2078 *
2079 * Only available if the reference is direct (i.e., not symbolic)
2080 */
2081 public object_id? target {
2082 [CCode(cname = "git_reference_target")]
2083 get;
2084 }
2085
2086 /**
2087 * The type of a reference
2088 *
2089 * Either direct, {@link ReferenceType.ID}, or symbolic, {@link ReferenceType.SYMBOLIC}
2090 */
2091 public ReferenceType type {
2092 [CCode(cname = "git_reference_type")]
2093 get;
2094 }
2095 /**
2096 * Ensure the reference name is well-formed.
2097 *
2098 * Valid reference names must follow one of two patterns:
2099 *
2100 * 1. Top-level names must contain only capital letters and underscores,
2101 * and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
2102 * 2. Names prefixed with "refs/" can be almost anything. You must avoid
2103 * the characters '~', '^', ':', '\\', '?', '[', and '*', and the
2104 * sequences ".." and "@{" which have special meaning to revparse.
2105 */
2106 [CCode(cname = "git_reference_is_valid_name")]
2107 public static bool is_valid_name(string refname);
2108
2109 /**
2110 * Delete an existing branch reference.
2111 */
2112 [CCode(cname = "git_branch_delete")]
2113 public static Error delete_branch(owned Reference reference);
2114 /**
2115 * Normalize the reference name by removing any leading slash (/)
2116 * characters and collapsing runs of adjacent slashes between name
2117 * components into a single slash.
2118 *
2119 * Once normalized, if the reference name is valid, it will be returned in
2120 * the user allocated buffer.
2121
2122 * @param buffer The buffer where the normalized name will be stored.
2123 * @param name name to be checked.
2124 * @param flags Flags to determine the options to be applied while checking
2125 * the validatity of the name.
2126 */
2127 [CCode(cname = "git_reference_normalize_name")]
2128 public static Error normalize_name([CCode(array_length_type = "size_t")] uint8[] buffer, string name, ReferenceFormat flags);
2129
2130 /**
2131 * Compare two references.
2132 *
2133 * @return 0 if the same, else a stable but meaningless ordering.
2134 */
2135 [CCode(cname = "git_reference_cmp")]
2136 public int compare(Reference other);
2137
2138 /**
2139 * Delete an existing reference
2140 *
2141 * This method works for both direct and symbolic references.
2142 *
2143 * The reference will be immediately removed on disk.
2144 */
2145 [CCode(cname = "git_reference_delete")]
2146 public void @delete();
2147
2148 /**
2149 * Delete the reflog for the given reference
2150 */
2151 [CCode(cname = "git_reflog_delete")]
2152 public Error delete_reflog();
2153
2154 /**
2155 * Return the name of the given local or remote branch.
2156 *
2157 * The name of the branch matches the definition of the name for
2158 * {@link Repository.lookup_branch}. That is, if the returned name is
2159 * looked up then the reference is returned that was given to this
2160 * function.
2161 *
2162 * @param name where the pointer of branch name is stored;
2163 * this is valid as long as the ref is not freed.
2164 */
2165 [CCode(cname = "git_branch_name", instance_pos = -1)]
2166 public Error get_branch_name(out unowned string name);
2167
2168 /**
2169 * Read the reflog for the given reference
2170 *
2171 * @param reflog where to put the reflog
2172 */
2173 [CCode(cname = "git_reflog_read", instance_pos = -1)]
2174 public Error get_reflog(out ReferenceLog? reflog);
2175 /**
2176 * Return the reference supporting the remote tracking branch, given a
2177 * reference branch.
2178 *
2179 * The input reference has to be located in the '''refs/heads''' namespace.
2180 *
2181 */
2182 [CCode(cname = "git_reference_remote_tracking_from_branch", instance_pos = -1)]
2183 public Error get_remote_tracking_from_branch(out Reference tracking_ref);
2184 /**
2185 * Return the reference supporting the remote tracking branch, given a
2186 * local branch reference.
2187 */
2188 [CCode(cname = "git_branch_tracking", instance_pos = -1)]
2189 public Error get_tracking(out Reference? tracking);
2190
2191 /**
2192 * Move/rename an existing branch reference.
2193 *
2194 * @param new_branch_name Target name of the branch once the move
2195 * is performed; this name is validated for consistency.
2196 *
2197 * @param force Overwrite existing branch.
2198 */
2199 [CCode(cname = "git_branch_move", instance_pos = 1.1)]
2200 public Error move_branch(out Reference? moved, string new_branch_name, bool force);
2201
2202 /**
2203 * Recursively peel an reference until an object of the specified type is
2204 * met.
2205 *
2206 * If you pass {@link ObjectType.ANY} as the target type, then the object
2207 * will be peeled until a non-tag object is met.
2208 *
2209 * @param target_type The type of the requested object
2210 */
2211 [CCode(cname = "git_reference_peel", instance_pos = 1.1)]
2212 public Error peel(out Object? peeled, ObjectType target_type);
2213
2214 /**
2215 * Rename an existing reference
2216 *
2217 * This method works for both direct and symbolic references.
2218 * The new name will be checked for validity and may be
2219 * modified into a normalized form.
2220 *
2221 * The refernece will be immediately renamed in-memory
2222 * and on disk.
2223 *
2224 * ''IMPORTANT:'' The user needs to write a proper reflog entry if the
2225 * reflog is enabled for the repository. We only rename the reflog if it
2226 * exists.
2227 *
2228 */
2229 [CCode(cname = "git_reference_rename", instance_pos = 1.1)]
2230 public Error rename(out Reference? renamed_reference, string new_name, bool force);
2231
2232 /**
2233 * Resolve a symbolic reference
2234 *
2235 * Thie method iteratively peels a symbolic reference
2236 * until it resolves to a direct reference to an id.
2237 *
2238 * If a direct reference is passed as an argument,
2239 * that reference is returned immediately
2240 *
2241 * @param resolved the peeled reference
2242 */
2243 [CCode(cname = "git_reference_resolve", instance_pos = -1)]
2244 public Error resolve(out Reference resolved);
2245
2246 /**
2247 * Create a new reference with the same name as the given reference but a
2248 * different symbolic target.
2249 *
2250 * The reference must be a symbolic reference, otherwise this will fail.
2251 *
2252 * The new reference will be written to disk, overwriting the given
2253 * reference.
2254 *
2255 * @param id the new target id for the reference
2256 */
2257 [CCode(cname = "git_reference_set_oid", instance_pos = 1.1)]
2258 public Error set_target(out Reference? retargeted, object_id id);
2259
2260 /**
2261 * Set the symbolic target of a reference.
2262 *
2263 * The reference must be a symbolic reference, otherwise this method will
2264 * fail.
2265 *
2266 * The reference will be automatically updated in memory and on disk.
2267 *
2268 * @param target The new target for the reference
2269 */
2270 [CCode(cname = "git_reference_symbolic_set_target")]
2271 public Error set_symbolic_target(string target);
2272 }
2273
2274 /**
2275 * Representation of a reference log
2276 */
2277 [CCode(cname = "git_reflog", free_function = "git_reflog_free", has_type_id = false)]
2278 [Compact]
2279 public class ReferenceLog {
2280 /**
2281 * The number of log entries in a reflog
2282 */
2283 public size_t size {
2284 [CCode(cname = "git_reflog_entrycount")]
2285 get;
2286 }
2287
2288 /**
2289 * Add a new entry to the reflog.
2290 *
2291 * If there is no reflog file for the given reference yet, it will be
2292 * created.
2293 *
2294 * @param id the id the reference is now pointing to
2295 * @param committer the signature of the committer
2296 * @param msg the reflog message
2297 */
2298 [CCode(cname = "git_reflog_append")]
2299 public Error append(out object_id id, Signature committer, string? msg = null);
2300
2301 /**
2302 * Remove an entry from the reflog by its index
2303 *
2304 * To ensure there's no gap in the log history, when deleting an entry,
2305 * member old_oid of the previous entry (if any) will be updated with the
2306 * value of memeber new_oid of next entry.
2307 *
2308 * @param idx the position of the entry to remove.
2309 *
2310 * @param rewrite_previous_entry true to rewrite the history; 0 otherwise.
2311 *
2312 */
2313 [CCode(cname = "git_reflog_drop")]
2314 public Error drop(size_t idx, bool rewrite_previous_entry);
2315
2316 /**
2317 * Lookup an entry by its index
2318 *
2319 * @param idx the position to lookup
2320 * @return the entry; null if not found
2321 */
2322 [CCode(cname = "git_reflog_entry_byindex")]
2323 public unowned ReferenceLogEntry? get(size_t idx);
2324
2325 /**
2326 * Rename the reflog for the given reference
2327 *
2328 * @param new_name the new name of the reference
2329 */
2330 [CCode(cname = "git_reflog_rename")]
2331 public Error rename(string new_name);
2332 /**
2333 * Write an existing in-memory reflog object back to disk using an atomic
2334 * file lock.
2335 *
2336 * If there is no reflog file for the given reference yet, it will be
2337 * created.
2338 */
2339 [CCode(cname = "git_reflog_write")]
2340 public Error write();
2341 }
2342
2343 /**
2344 * Representation of a reference log entry
2345 */
2346 [CCode(cname = "git_reflog_entry", has_type_id = false)]
2347 [Compact]
2348 public class ReferenceLogEntry {
2349
2350 /**
2351 * The committer of this entry
2352 */
2353 public Signature commiter {
2354 [CCode(cname = "git_reflog_entry_committer")]
2355 get;
2356 }
2357
2358 /**
2359 * The log message
2360 */
2361 public string message {
2362 [CCode(cname = "git_reflog_entry_msg")]
2363 get;
2364 }
2365
2366 /**
2367 * The new id at this time
2368 */
2369 public object_id? new_id {
2370 [CCode(cname = "git_reflog_entry_id_new")]
2371 get;
2372 }
2373
2374 /**
2375 * The old id
2376 */
2377 public object_id? old_id {
2378 [CCode(cname = "git_reflog_entry_id_old")]
2379 get;
2380 }
2381 }
2382
2383 /**
2384 * Reference to a remote repository
2385 */
2386 [CCode(cname = "git_remote", free_function = "git_remote_free", has_type_id = false)]
2387 [Compact]
2388 public class Remote {
2389 [CCode(cname = "git_remote_rename_problem_cb")]
2390 public delegate bool RenameProblem(string problematic_refspec);
2391 /**
2392 * The tag auto-follow setting
2393 */
2394 public AutoTag autotag {
2395 [CCode(cname = "git_remote_autotag")]
2396 get;
2397 [CCode(cname = "git_remote_set_autotag")]
2398 set;
2399 }
2400
2401 /**
2402 * Choose whether to check the server's certificate (applies to HTTPS only)
2403 */
2404 public bool check_cert {
2405 [CCode(cname = "git_remote_check_cert")]
2406 set;
2407 }
2408
2409 /**
2410 * Whether the remote is connected
2411 *
2412 * Whether the remote's underlying transport is connected to the remote
2413 * host.
2414 */
2415 public bool is_connected {
2416 [CCode(cname = "git_remote_connected")]
2417 get;
2418 }
2419
2420 /**
2421 * The fetch refspec, if it exists
2422 */
2423 public ref_spec? fetch_spec {
2424 [CCode(cname = "git_remote_fetchspec")]
2425 get;
2426 [CCode(cname = "git_remote_set_fetchspec")]
2427 set;
2428 }
2429
2430 /**
2431 * The remote's name
2432 */
2433 public string? name {
2434 [CCode(cname = "git_remote_name")]
2435 get;
2436 }
2437
2438 /**
2439 * The push refspec, if it existsc
2440 */
2441 public ref_spec? push_spec {
2442 [CCode(cname = "git_remote_pushspec")]
2443 get;
2444 [CCode(cname = "git_remote_set_pushspec")]
2445 set;
2446 }
2447
2448 /**
2449 * The statistics structure that is filled in by the fetch operation.
2450 */
2451 public transfer_progress stats {
2452 [CCode(cname = "git_remote_stats")]
2453 get;
2454 }
2455
2456 /**
2457 * Update FETCH_HEAD on ever fetch.
2458 */
2459 public bool update_fetchhead {
2460 [CCode(cname = "git_remote_update_fetchhead")]
2461 get;
2462 [CCode(cname = "git_remote_set_update_fetchhead")]
2463 set;
2464 }
2465 /**
2466 * The remote's URL
2467 */
2468 public string url {
2469 [CCode(cname = "git_remote_url")]
2470 get;
2471 }
2472
2473 /**
2474 * Ensure the remote name is well-formed.
2475 *
2476 * @param remote_name name to be checked.
2477 */
2478 [CCode(cname = "git_remote_is_valid_name")]
2479 public static bool is_valid_name(string remote_name);
2480
2481 /**
2482 * Return whether a string is a valid remote URL
2483 *
2484 * @param url the url to check
2485 */
2486 [CCode(cname = "git_remote_valid_url")]
2487 public static bool is_valid_url(string url);
2488
2489 /**
2490 * Return whether the passed URL is supported by this version of the library.
2491 *
2492 * @param url the url to check
2493 */
2494 [CCode(cname = "git_remote_supported_url")]
2495 public static bool is_supported_url(string url);
2496 /**
2497 * Create a new push object
2498 */
2499 [CCode(cname = "git_push_new", instance_pos = -1)]
2500 public Error create_push(out Push? push);
2501
2502 /**
2503 * Open a connection to a remote
2504 *
2505 * The transport is selected based on the URL. The direction argument is
2506 * due to a limitation of the git protocol (over TCP or SSH) which starts
2507 * up a specific binary which can only do the one or the other.
2508 *
2509 * @param direction whether you want to receive or send data
2510 */
2511 [CCode(cname = "git_remote_connect")]
2512 public Error connect(Direction direction);
2513
2514 /**
2515 * Download the packfile
2516 *
2517 * Negotiate what objects should be downloaded and download the packfile
2518 * with those objects.
2519 */
2520 [CCode(cname = "git_remote_download")]
2521 public Error download(Progress progress);
2522
2523 /**
2524 * Disconnect from the remote
2525 *
2526 * Close the connection to the remote and free the underlying transport.
2527 */
2528 [CCode(cname = "git_remote_disconnect")]
2529 public void disconnect();
2530
2531 /**
2532 * Get a list of refs at the remote
2533 *
2534 * The remote (or more exactly its transport) must be connected.
2535 */
2536 [CCode(cname = "git_remote_ls", instance_pos = -1)]
2537 public Error list(Head headcb);
2538
2539 /**
2540 * Give the remote a new name
2541 *
2542 * All remote-tracking branches and configuration settings for the remote
2543 * are updated.
2544 *
2545 * The new name will be checked for validity.
2546 *
2547 * A temporary in-memory remote cannot be given a name with this method.
2548 *
2549 * @param new_name the new name the remote should bear
2550 * @param rename_problem Optional callback to notify the consumer of fetch refspecs
2551 * that haven't been automatically updated and need potential manual tweaking.
2552 * @see Repository.create_tag
2553 */
2554 [CCode(cname = "git_remote_rename")]
2555 public Error rename(string new_name, RenameProblem? rename_problem = null);
2556 /**
2557 * Save a remote to its repository's configuration
2558 *
2559 * One can't save a in-memory remote. Doing so will result in a
2560 * {@link Error.INVALIDSPEC} being returned.
2561 */
2562 [CCode(cname = "git_remote_save")]
2563 public Error save();
2564 /**
2565 * Set the callbacks for a remote
2566 */
2567 [CCode(cname = "git_remote_set_callbacks", simple_generics = true)]
2568 public Error set_callbacks<T>(remote_callbacks<T> callbacks);
2569
2570 /**
2571 * Sets the owning repository for the remote. This is only allowed on
2572 * dangling remotes.
2573 */
2574 [CCode(cname = "git_remote_set_repository")]
2575 public Error set_repository(Repository repo);
2576
2577 /**
2578 * Sets a credentials acquisition callback for this remote.
2579 *
2580 * If the remote is not available for anonymous access, then you must set
2581 * this callback in order to provide credentials to the transport at the
2582 * time of authentication failure so that retry can be performed.
2583 */
2584 [CCode(cname = "git_remote_set_cred_acquire_cb")]
2585 public void set_cred_acquire(CredAcquire? cred_acquire);
2586
2587 /**
2588 * Sets a custom transport for the remote. The caller can use this function
2589 * to bypass the automatic discovery of a transport by URL scheme (i.e.,
2590 * http, https, git) and supply their own transport to be used
2591 * instead. After providing the transport to a remote using this function,
2592 * the transport object belongs exclusively to that remote, and the remote will
2593 * free it when it is freed with git_remote_free.
2594 *
2595 * @param transport the transport object for the remote to use
2596 */
2597 [CCode(cname = "git_remote_set_transport")]
2598 public Error set_transport(transport transport);
2599
2600 /**
2601 * Cancel the operation
2602 *
2603 * At certain points in its operation, the network code checks whether the
2604 * operation has been cancelled and if so stops the operation.
2605 */
2606 [CCode(cname = "git_remote_stop")]
2607 public void stop();
2608
2609 /**
2610 * Update the tips to the new state
2611 *
2612 * Make sure that you only call this once you've successfully indexed or
2613 * expanded the packfile.
2614 */
2615 [CCode(cname = "git_remote_update_tips")]
2616 public Error update_tips(Update update);
2617 }
2618
2619 /**
2620 * Representation of an existing git repository,
2621 * including all its object contents
2622 */
2623 [CCode(cname = "git_repository", free_function = "git_repository_free", has_type_id = false)]
2624 [Compact]
2625 public class Repository {
2626 public Attr attributes {
2627 [CCode(cname = "")]
2628 get;
2629 }
2630 /**
2631 * Check if a repository is bare
2632 */
2633 public bool is_bare {
2634 [CCode(cname = "git_repository_is_bare")]
2635 get;
2636 }
2637 /**
2638 * Check if a repository's HEAD is detached
2639 *
2640 * A repository's HEAD is detached when it points directly to a commit
2641 * instead of a branch.
2642 */
2643 public bool is_head_detached {
2644 [CCode(cname = "git_repository_head_detached")]
2645 get;
2646 }
2647
2648 /**
2649 * Check if the current branch is an orphan
2650 *
2651 * An orphan branch is one named from HEAD but which doesn't exist in
2652 * the refs namespace, because it doesn't have any commit to point to.
2653 */
2654 public bool is_head_orphan {
2655 [CCode(cname = "git_repository_head_orphan")]
2656 get;
2657 }
2658
2659 /**
2660 * Check if a repository is empty
2661 *
2662 * An empty repository has just been initialized and contains no commits.
2663 */
2664 public bool is_empty {
2665 [CCode(cname = "git_repository_is_empty")]
2666 get;
2667 }
2668
2669 /**
2670 * The path to the repository.
2671 */
2672 public string? path {
2673 [CCode(cname = "git_repository_path")]
2674 get;
2675 }
2676 /**
2677 * Determines the status of a git repository (i.e., whether an operation
2678 * such as a merge or cherry-pick is in progress).
2679 */
2680 public State state {
2681 [CCode(cname = "git_repository_state")]
2682 get;
2683 }
2684
2685 /**
2686 * The working directory for this repository
2687 *
2688 * If the repository is bare, this is null.
2689 *
2690 * If this repository is bare, setting its working directory will turn it
2691 * into a normal repository, capable of performing all the common workdir
2692 * operations (checkout, status, index manipulation, etc).
2693 */
2694 public string? workdir {
2695 [CCode(cname = "git_repository_workdir")]
2696 get;
2697 set {
2698 set_workdir((!)value, true);
2699 }
2700 }
2701
2702 /**
2703 * Clone a remote repository, and checkout the branch pointed to by the remote
2704 * HEAD.
2705 *
2706 * @param origin_url repository to clone from
2707 * @param dest_path local directory to clone to
2708 * @param clone_opts configuration options for the clone.
2709 */
2710 [CCode(cname = "git_clone")]
2711 public static Error clone(out Repository? repo, string origin_url, string dest_path, clone_opts? clone_opts = null);
2712
2713 /**
2714 * Look for a git repository and copy its path in the given buffer. The lookup start
2715 * from base_path and walk across parent directories if nothing has been found. The
2716 * lookup ends when the first repository is found, or when reaching a directory
2717 * referenced in ceiling_dirs or when the filesystem changes (in case across_fs
2718 * is true).
2719 *
2720 * The method will automatically detect if the repository is bare (if there is
2721 * a repository).
2722 *
2723 * @param repository_path The buffer which will contain the found path.
2724 *
2725 * @param start_path The base path where the lookup starts.
2726 *
2727 * @param across_fs If true, then the lookup will not stop when a filesystem device change
2728 * is detected while exploring parent directories.
2729 *
2730 * @param ceiling_dirs A {@link PATH_LIST_SEPARATOR} separated list of absolute symbolic link free paths. The lookup will stop when any of this paths is reached. Note that the lookup always performs on //start_path// no matter start_path appears in //ceiling_dirs//. //ceiling_dirs// might be null, which is equivalent to an empty string.
2731 */
2732 public static Error discover([CCode(array_length_type = "size_t")] char[] repository_path, string start_path, bool across_fs = true, string? ceiling_dirs = null);
2733
2734 /**
2735 * Creates a new Git repository in the given folder.
2736 *
2737 * @param repo the repo which will be created or reinitialized
2738 * @param path the path to the repository
2739 * @param is_bare if true, a git repository without a working directory is created at the pointed path. If false, provided path will be considered as the working directory into which the //.git// directory will be created.
2740 */
2741 [CCode(cname = "git_repository_init")]
2742 public static Error init(out Repository repo, string path, bool is_bare);
2743 /**
2744 * Create a new Git repository in the given folder with extended controls.
2745 *
2746 * This will initialize a new git repository (creating the path if
2747 * requested by flags) and working directory as needed. It will
2748 * auto-detect the case sensitivity of the file system and if the file
2749 * system supports file mode bits correctly.
2750 *
2751 * @param repo_path The path to the repository.
2752 * @param opts Pointer to git_repository_init_options struct.
2753 */
2754 [CCode(cname = "git_repository_init_ext")]
2755 public static Error init_ext(out Repository? repo, string repo_path, init_options opts);
2756
2757 /**
2758 * Open a git repository.
2759 *
2760 * The path argument must point to an existing git repository
2761 * folder. The repository can be normal (having a //.git// directory)
2762 * or bare (having objects, index, and HEAD directly).
2763 * The method will automatically detect if path is a normal
2764 * or bare repository or fail is path is neither.
2765 *
2766 * @param repository the repo which will be opened
2767 * @param path the path to the repository
2768 */
2769 [CCode(cname = "git_repository_open")]
2770 public static Error open(out Repository? repository, string path);
2771
2772 /**
2773 * Find and open a repository with extended controls.
2774 */
2775 [CCode(cname = "git_repository_open_ext")]
2776 public static Error open_ext(out Repository? repository, string start_path, OpenFlags flags, string ceiling_dirs);
2777 /**
2778 * Add ignore rules for a repository.
2779 *
2780 * Excludesfile rules (i.e. .gitignore rules) are generally read from
2781 * .gitignore files in the repository tree or from a shared system file
2782 * only if a "core.excludesfile" config value is set. The library also
2783 * keeps a set of per-repository internal ignores that can be configured
2784 * in-memory and will not persist. This function allows you to add to
2785 * that internal rules list.
2786 *
2787 * @param rules Text of rules, a la the contents of a .gitignore file. It
2788 * is okay to have multiple rules in the text; if so, each rule should be
2789 * terminated with a newline.
2790 */
2791 [CCode(cname = "git_ignore_add_rule")]
2792 public Error add_ignore(string rules);
2793 /**
2794 * Set up a new git submodule for checkout.
2795 *
2796 * This does '''git submodule add''' up to the fetch and checkout of the
2797 * submodule contents. It preps a new submodule, creates an entry in
2798 * .gitmodules and creates an empty initialized repository either at the
2799 * given path in the working directory or in .git/modules with a gitlink
2800 * from the working directory to the new repo.
2801 *
2802 * To fully emulate '''git submodule add''' call this function, then open
2803 * the submodule repo and perform the clone step as needed. Lastly, call
2804 * {@link Submodule.add_finalize} to wrap up adding the new submodule and
2805 * .gitmodules to the index to be ready to commit.
2806 *
2807 * @param submodule The newly created submodule ready to open for clone
2808 * @param url URL for the submodules remote
2809 * @param path Path at which the submodule should be created
2810 * @param use_gitlink Should workdir contain a gitlink to the repo in
2811 * .git/modules vs. repo directly in workdir.
2812 */
2813 [CCode(cname = "git_submodule_add_setup", instance_pos = 1.1)]
2814 public Error add_submodule_setup(out Submodule? submodule, string url, string path, bool use_gitlink);
2815
2816 /**
2817 * Remove all the metadata associated with an ongoing git merge, including
2818 * MERGE_HEAD, MERGE_MSG, etc.
2819 */
2820 [CCode(cname = "git_repository_merge_cleanup")]
2821 public Error cleanup_merge();
2822
2823 /**
2824 * Clear ignore rules that were explicitly added.
2825 *
2826 * Resets to the default internal ignore rules. This will not turn off
2827 * rules in .gitignore files that actually exist in the filesystem.
2828 *
2829 * The default internal ignores ignore '''.''', '''..''' and '''.git''' entries.
2830 */
2831 public Error clear_internal_ignores();
2832
2833 /**
2834 * Updates files in the index and the working tree to match the commit pointed to by HEAD.
2835 *
2836 * @param opts specifies checkout options
2837 */
2838 [CCode(cname = "git_checkout_head")]
2839 public Error checkout_head(checkout_opts? opts = null);
2840 /**
2841 * Updates files in the working tree to match the content of the index.
2842 *
2843 * @param opts specifies checkout options
2844 * @param index index to be checked out (or null to use repository index)
2845 */
2846 [CCode(cname = "git_checkout_index")]
2847 public Error checkout_index(Index? index = null, checkout_opts? opts = null);
2848 /**
2849 * Updates files in the index and working tree to match the content of a
2850 * tree.
2851 *
2852 * @param treeish a commit, tag or tree which content will be used to
2853 * update the working directory
2854 * @param opts specifies checkout options
2855 */
2856 [CCode(cname = "git_checkout_tree")]
2857 public Error checkout_tree(Object treeish, checkout_opts? opts = null);
2858 /**
2859 * Count the number of unique commits between two commit objects
2860 *
2861 * There is no need for branches containing the commits to have any
2862 * upstream relationship, but it helps to think of one as a branch and the
2863 * other as its upstream, the ahead and behind values will be what git
2864 * would report for the branches.
2865 *
2866 * @param ahead number of unique commits in upstream
2867 * @param behind number of unique commits in local
2868 * @param local one of the commits
2869 * @param upstream the other commit
2870 */
2871 [CCode(cname = "git_graph_ahead_behind", instance_pos = 2.1)]
2872 public Error count_ahead_behind(out size_t ahead, out size_t behind, object_id local, object_id upstream);
2873 /**
2874 * Write an in-memory buffer to the ODB as a blob
2875 *
2876 * @param id return the id of the written blob
2877 * @param buffer data to be written into the blob
2878 */
2879 [CCode(cname = "git_blob_create_frombuffer", instance_pos = 1.2)]
2880 public Error create_blob_from_buffer(object_id id, [CCode(array_length_type = "size_t")] uint8[] buffer);
2881 /**
2882 * Write a loose blob to the Object Database from a provider of chunks of
2883 * data.
2884 *
2885 * @param id Return the id of the written blob
2886 * @param hint_path will help to determine what git filters should be
2887 * applied to the object before it can be placed to the object database.
2888 */
2889 [CCode(cname = "git_blob_create_fromchunks", instance_pos = 1.2)]
2890 public Error create_blob_from_chunks(object_id id, string? hint_path, ChunkSource source);
2891
2892 /**
2893 * Read a file from the filesystem and write its content to the Object
2894 * Database as a loose blob
2895 *
2896 * @param id return the id of the written blob
2897 * @param path file from which the blob will be created
2898 */
2899 [CCode(cname = "git_blob_create_fromdisk", instance_pos = 1.2)]
2900 public Error create_blob_from_disk(out object_id id, string path);
2901
2902 /**
2903 * Read a file from the working folder of a repository
2904 * and write it to the object database as a loose blob
2905 *
2906 * This repository cannot be bare.
2907 *
2908 * @param id return the id of the written blob
2909 * @param path file from which the blob will be created, relative to the repository's working dir
2910 */
2911 [CCode(cname = "git_blob_create_fromworkdir", instance_pos = 1.2)]
2912 public Error create_blob_from_file(object_id id, string path);
2913
2914 /**
2915 * Create a new branch pointing at a target commit
2916 *
2917 * A new direct reference will be created pointing to this target commit.
2918 * If forced and a reference already exists with the given name, it'll be
2919 * replaced.
2920 *
2921 * @param branch_name Name for the branch; this name is
2922 * validated for consistency. It should also not conflict with
2923 * an already existing branch name.
2924 *
2925 * @param target Object to which this branch should point. This object must
2926 * belong to the given repository and can either be a commit or a tag. When
2927 * a tag is being passed, it should be dereferencable to a commit which oid
2928 * will be used as the target of the branch.
2929 *
2930 * @param force Overwrite existing branch.
2931 */
2932 [CCode(cname = "git_branch_create", instance_pos = 1.2)]
2933 public Error create_branch(out Reference? branch, string branch_name, Commit target, bool force = false);
2934
2935 /**
2936 * Create a new commit in the repository using {@link Object}
2937 * instances as parameters.
2938 *
2939 * The message will not be cleaned up.
2940 *
2941 * @param id the id of the newly created commit
2942 *
2943 * @param update_ref If not null, name of the reference that will be updated to point to this commit. If the reference is not direct, it will be resolved to a direct reference. Use //"HEAD"// to update the HEAD of the current branch and make it point to this commit.
2944 * @param author Signature representing the author and the author time of this commit
2945 * @param committer Signature representing the committer and the commit time of this commit
2946 * @param message_encoding The encoding for the message in the commit, represented with a standard encoding name (e.g., //"UTF-8"//). If null, no encoding header is written and UTF-8 is assumed.
2947 * @param message Full message for this commit
2948 * @param tree The tree that will be used as the tree for the commit. This tree object must also be owned by this repository.
2949 * @param parents The commits that will be used as the parents for this commit. This array may be empty for the root commit. All the given commits must be owned by this repository.
2950 * @see prettify_message
2951 */
2952 [CCode(cname = "git_commit_create", instance_pos = 1.2)]
2953 public Error create_commit(object_id id, string? update_ref, Signature author, Signature committer, string? message_encoding, string message, Tree tree, [CCode(array_length_pos = 7.8)] Commit[] parents);
2954
2955 /**
2956 * Create a new commit in the repository using a variable argument list.
2957 *
2958 * The parents for the commit are specified as a variable arguments. Note
2959 * that this is a convenience method which may not be safe to export for
2960 * certain languages or compilers
2961 *
2962 * The message will be cleaned up from excess whitespace it will be made
2963 * sure that the last line ends with a new line.
2964 *
2965 * All other parameters remain the same.
2966 *
2967 * @see create_commit
2968 */
2969 [CCode(cname = "git_commit_create_v", instance_pos = 1.2)]
2970 public Error create_commit_v(object_id id, string update_ref, Signature author, Signature committer, string message_encoding, string message, Tree tree, int parent_count, ...);
2971
2972 /**
2973 * Create a new lightweight tag pointing at a target object
2974 *
2975 * A new direct reference will be created pointing to this target object.
2976 * If //force// is true and a reference already exists with the given name,
2977 * it'll be replaced.
2978 *
2979 * The message will be cleaned up from excess whitespace
2980 * it will be made sure that the last line ends with a new line.
2981 *
2982 * @param id where to store the id of the newly created tag. If the tag already exists, this parameter will be the id of the existing tag, and the function will return a {@link Error.EXISTS} error code.
2983 *
2984 * @param tag_name Name for the tag; this name is validated for consistency. It should also not conflict with an already existing tag name.
2985 *
2986 * @param target Object to which this tag points. This object must belong to this repository.
2987 *
2988 * @param force Overwrite existing references
2989 *
2990 * @return on success, a proper reference is written in the ///refs/tags// folder, pointing to the provided target object
2991 * @see create_tag
2992 */
2993 [CCode(cname = "git_tag_create_lightweight", instance_pos = 1.2)]
2994 public Error create_lightweight_tag(object_id id, string tag_name, Object target, bool force);
2995
2996 /**
2997 * Add a note for an object
2998 *
2999 * @param note_id the object id of the note crated
3000 * @param author signature of the notes commit author
3001 * @param committer signature of the notes commit committer
3002 * @param notes_ref ID reference to update (optional); defaults to "refs/notes/commits"
3003 * @param id The ID of the object
3004 * @param note The note to add for the object
3005 * @param force Overwrite existing note
3006 */
3007 [CCode(cname = "git_note_create", instance_pos = 1.2)]
3008 public Error create_note(out object_id note_id, Signature author, Signature committer, string? notes_ref, object_id id, string note, bool force = false);
3009
3010 /**
3011 * Creates a new iterator for notes.
3012 *
3013 * @param notes_ref canonical name of the reference to use (optional);
3014 * defaults to "refs/notes/commits"
3015 */
3016 [CCode(cname = "git_note_iterator_new", instance_pos = 1.1)]
3017 public Error create_note_iterator(out NoteIterator? iterator, string? notes_ref = null);
3018
3019 /**
3020 * Initialize a new packbuilder
3021 *
3022 * @param pack_builder The new packbuilder object
3023 */
3024 [CCode(cname = "git_packbuilder_new", instance_pos = -1)]
3025 public Error create_pack_builder(out PackBuilder? pack_builder);
3026
3027 /**
3028 * Create a new reference database with no backends.
3029 *
3030 * Before the Ref DB can be used for read/writing, a custom database
3031 * backend must be manually set using {@link RefDb.set_backend}.
3032 */
3033 [CCode(cname = "git_refdb_new", instance_pos = -1)]
3034 public Error create_refdb(out RefDb? refdb);
3035
3036 /**
3037 * Create a new object id reference.
3038 *
3039 * The reference will be created in the repository and written to the disk.
3040 *
3041 * @param reference the newly created reference
3042 * @param name The name of the reference
3043 * @param id The object id pointed to by the reference.
3044 * @param force Overwrite existing references
3045 */
3046 [CCode(cname = "git_reference_create", instance_pos = 1.2)]
3047 public Error create_reference(out unowned Reference reference, string name, object_id id, bool force);
3048
3049 /**
3050 * Add a remote with the default fetch refspec to the repository's configuration.
3051 *
3052 * This calls {@link Remote.save} before returning.
3053 *
3054 * @param remote the resulting remote
3055 * @param name the remote's name
3056 * @param url the remote's url
3057 */
3058 [CCode(cname = "git_remote_create", instance_pos = 1.2)]
3059 public Error create_remote(out Remote? remote, string name, string url);
3060 /**
3061 * Create a remote with the given refspec in memory.
3062 *
3063 * You can use this when you have a URL instead of a remote's name. Note
3064 * that in-memory remotes cannot be converted to persisted remotes.
3065 *
3066 * @param remote the newly created remote reference
3067 * @param fetch the fetch refspec to use for this remote; null for defaults
3068 * @param url the remote repository's URL
3069 */
3070 [CCode(cname = "git_remote_create_inmemory", instance_pos = 1.2)]
3071 public Error create_remote_in_memory(out Remote? remote, string? fetch, string url);
3072
3073 /**
3074 * Create a new symbolic reference.
3075 *
3076 * The reference will be created in the repository and written to the disk.
3077 *
3078 * @param reference the newly created reference
3079 * @param name The name of the reference
3080 * @param target The target of the reference
3081 * @param force Overwrite existing references
3082 */
3083 [CCode(cname = "git_reference_symbolic_create", instance_pos = 1.2)]
3084 public Error create_symbolic_reference(out unowned Reference reference, string name, string target, bool force);
3085
3086 /**
3087 * Create a new tag in the repository from an object
3088 *
3089 * A new reference will also be created pointing to this tag object. If
3090 * //force// is true and a reference already exists with the given name,
3091 * it'll be replaced.
3092 *
3093 * The tag name will be checked for validity. You must avoid the characters
3094 * ~, ^, :, \, ?, [, and *, and the sequences '''..''' and '''@{''' which
3095 * have special meaning to revparse.
3096 *
3097 * @param id where to store the id of the newly created tag. If the tag already exists, this parameter will be the id of the existing tag, and the function will return a {@link Error.EXISTS} error code.
3098 * @param tag_name Name for the tag; this name is validated for consistency. It should also not conflict with an already existing tag name.
3099 * @param target Object to which this tag points. This object must belong to this repository.
3100 * @param tagger Signature of the tagger for this tag, and of the tagging time
3101 * @param message Full message for this tag
3102 * @param force Overwrite existing references
3103 * @return on success, a tag object is written to the ODB, and a proper reference is written in the ///refs/tags// folder, pointing to it
3104 */
3105 [CCode(cname = "git_tag_create", instance_pos = 1.2)]
3106 public Error create_tag(object_id id, string tag_name, Object target, Signature tagger, string message, bool force);
3107
3108 /**
3109 * Create a new tag in the repository from a buffer
3110 *
3111 * @param id Pointer where to store the id of the newly created tag
3112 * @param buffer Raw tag data
3113 * @param force Overwrite existing tags
3114 * @see create_tag
3115 */
3116 [CCode(cname = "git_tag_create_frombuffer", instance_pos = 1.2)]
3117 public Error create_tag_from_buffer(object_id id, string buffer, bool force);
3118
3119 /**
3120 * Delete an existing tag reference.
3121 *
3122 * @param tag_name Name of the tag to be deleted; this name is validated for consistency.
3123 */
3124 [CCode(cname = "git_tag_delete")]
3125 public Error delete_tag(string tag_name);
3126
3127 /**
3128 * Detach the HEAD.
3129 *
3130 * If the HEAD is already detached and points to a commit, the call is successful.
3131 *
3132 * If the HEAD is already detached and points to a tag, the HEAD is updated
3133 * into making it point to the peeled commit, and the call is successful.
3134 *
3135 * If the HEAD is already detached and points to a non commitish, the HEAD
3136 * is unaletered, and an error is returned.
3137 *
3138 * Otherwise, the HEAD will be detached and point to the peeled commit.
3139 */
3140 [CCode(cname = "git_repository_detach_head")]
3141 public Error detach_head();
3142
3143 /**
3144 * Compute a difference between two tree objects.
3145 *
3146 * @param diff The diff that will be allocated.
3147 * @param old_tree A tree to diff from.
3148 * @param new_tree A tree to diff to.
3149 * @param opts Structure with options to influence diff or null for defaults.
3150 */
3151 [CCode(cname = "git_diff_tree_to_tree", instance_pos = 1.1)]
3152 public Error diff_tree_to_tree(out DiffList? diff, Tree old_tree, Tree new_tree, diff_options? opts = null);
3153
3154 /**
3155 * Compute a difference between a tree and the index.
3156 *
3157 * @param diff The diff that will be allocated.
3158 * @param old_tree A tree object to diff from.
3159 * @param opts Structure with options to influence diff or null for defaults.
3160 */
3161 [CCode(cname = "git_diff_tree_to_index", instance_pos = 1.1)]
3162 public Error diff_tree_to_index(out DiffList? diff, Tree old_tree, diff_options? opts = null);
3163
3164 /**
3165 * Compute a difference between the working directory and the index.
3166 *
3167 * @param diff A pointer to a git_diff_list pointer that will be allocated.
3168 * @param opts Structure with options to influence diff or null for defaults.
3169 */
3170 [CCode(cname = "git_diff_index_to_workdir", instance_pos = 1.1)]
3171 public Error diff_index_to_workdir(out DiffList? diff, diff_options? opts = null);
3172
3173 /**
3174 * Compute a difference between the working directory and a tree.
3175 *
3176 * Please note: this is //not// the same as '''git diff //treeish//'''.
3177 * Running '''git diff HEAD''' or the like actually uses information from
3178 * the index, along with the tree and working directory info.
3179 *
3180 * This function returns strictly the differences between the tree and the
3181 * The tree you provide will be used for the {@link diff_delta.old_file}
3182 * side of the delta, and the working directory will be used for the
3183 * {@link diff_delta.new_file} side.
3184 *
3185 * Files contained in the working directory, regardless of the state of
3186 * files in the index. It may come as a surprise, but there is no direct
3187 * equivalent in core git.
3188 *
3189 * This is //not// the same as '''git diff HEAD''' or '''git diff <SHA>'''.
3190 * Those commands diff the tree, the index, and the workdir. To emulate
3191 * those functions, call {@link diff_tree_to_index} and
3192 * {@link diff_index_to_workdir}, then call {@link DiffList.merge} on the
3193 * results.
3194 *
3195 * If this seems confusing, take the case of a file with a staged deletion
3196 * where the file has then been put back into the working dir and modified.
3197 * The tree-to-workdir diff for that file is 'modified', but core git would
3198 * show status 'deleted' since there is a pending deletion in the index.
3199 *
3200 * @param old_tree A tree to diff from.
3201 * @param opts Structure with options to influence diff or NULL for defaults.
3202 */
3203 [CCode(cname = "git_diff_workdir_to_tree", instance_pos = 1.1)]
3204 public Error diff_tree_to_workdir(out DiffList? diff, Tree old_tree, diff_options? opts = null);
3205
3206 /**
3207 * Remove a single stashed state from the stash list.
3208 * @param index The position within the stash list. 0 points to the
3209 * most recent stashed state.
3210 */
3211 [CCode(cname = "git_stash_drop")]
3212 public Error drop_stash(size_t index);
3213
3214 /**
3215 * Iterate over each entry in the FETCH_HEAD file.
3216 */
3217 [CCode(cname = "git_repository_fetchhead_foreach")]
3218 public Error for_each_fetchhead(FetchHeadForEach fetch_head_for_each);
3219
3220 /**
3221 * If a merge is in progress, iterate over each commit ID in the MERGE_HEAD
3222 * file.
3223 */
3224 [CCode(cname = "git_repository_mergehead_foreach")]
3225 public Error for_each_merge_head(MergeHeadForEach merge_head_for_each);
3226
3227 /**
3228 * Perform an operation on each reference in the repository
3229 *
3230 * The processed references may be filtered by type, or using a bitwise OR
3231 * of several types. Use the magic value {@link ReferenceType.LISTALL} to
3232 * obtain all references, including packed ones.
3233 *
3234 * @param list_flags Filtering flags for the reference listing.
3235 * @param reference_for_each Function which will be called for every listed ref
3236 */
3237 [CCode(cname = "git_reference_foreach")]
3238 public Error for_each_reference(ReferenceType list_flags, ReferenceForEach reference_for_each);
3239 /**
3240 * Loop over all the references and issue a callback for each one which
3241 * name matches the given glob pattern.
3242 *
3243 * @param list_flags Filtering flags for the reference listing.
3244 * @param reference_for_each to invoke per found reference.
3245 */
3246 [CCode(cname = "git_reference_foreach_glob")]
3247 public Error for_each_reference_glob(string glob, ReferenceType list_flags, ReferenceForEach reference_for_each);
3248
3249 /**
3250 * Iterate over all submodules of a repository.
3251 */
3252 [CCode(cname = "git_submodule_foreach")]
3253 public Error for_each_submodule(SubmoduleForEach submodule_for_each);
3254 /**
3255 * Iterate over each tag in the repository.
3256 */
3257 [CCode(cname = "git_tag_foreach")]
3258 public Error for_each_tag(TagForEach tag_for_each);
3259
3260 /**
3261 * Find a merge base between two commits
3262 *
3263 * @param merge_base the OID of a merge base between 'one' and 'two'
3264 * @param one one of the commits
3265 * @param two the other commit
3266 */
3267 [CCode(cname = "git_merge_base", instance_pos = 1.2)]
3268 public Error find_merge_base(out object_id merge_base, object_id one, object_id two);
3269
3270 /**
3271 * Find a merge base given a list of commits
3272 *
3273 * @param id the ID of a merge base considering all the commits
3274 * @param input ids of the commits
3275 */
3276 [CCode(cname = "git_merge_base_many", instance_pos = 1.1)]
3277 public Error find_merge_base_many(out object_id id, [CCode(array_length_type = "size_t")]object_id[] input);
3278
3279 /**
3280 * Loop over all the notes within a specified namespace.
3281 * @param notes_ref OID reference to read from (optional); defaults to "refs/notes/commits".
3282 */
3283 [CCode(cname = "git_note_foreach")]
3284 public Error for_each_note(string? notes_ref, NoteForEach note_for_each);
3285
3286 /**
3287 * Loop over all the stashed states.
3288 *
3289 * The most recent stash state will be enumerated first.
3290 */
3291 [CCode(cname = "git_stash_foreach")]
3292 public Error for_each_stash(StashForEach stash_for_each);
3293
3294 /**
3295 * Gather file statuses and run a callback for each one.
3296 *
3297 * The callback is passed the path of the file, the status and the data
3298 * pointer passed to this function. If the callback returns something other
3299 * than {@link Error.OK}, this function will return that value.
3300 *
3301 * @param status_for_each the function to call on each file
3302 * @return {@link Error.OK} or the return value of the callback
3303 */
3304 [CCode(cname = "git_status_foreach")]
3305 public Error for_each_status(StatusForEach status_for_each);
3306
3307 /**
3308 * Gather file status information and run callbacks as requested.
3309 */
3310 [CCode(cname = "git_status_foreach_ext")]
3311 public Error for_each_status_ext(status_options opts, StatusForEach status_for_each);
3312
3313 /**
3314 * Get the configuration file for this repository.
3315 *
3316 * If a configuration file has not been set, the default
3317 * config set for the repository will be returned, including
3318 * global and system configurations (if they are available).
3319 *
3320 * @param config the repository's configuration
3321 */
3322 [CCode(cname = "git_repository_config", instance_pos = -1)]
3323 public Error get_config(out Config config);
3324
3325 /**
3326 * Get the Object Database for this repository.
3327 *
3328 * If a custom ODB has not been set, the default database for the
3329 * repository will be returned (the one located in //.git/objects//).
3330 */
3331 [CCode(cname = "git_repository_odb", instance_pos = -1)]
3332 public Error get_db(out Database.Handle db);
3333
3334 /**
3335 * Get file status for a single file
3336 *
3337 * @param status the status value
3338 * @param path the file to retrieve status for, rooted at the repo's workdir
3339 * @return {@link Error.ERROR} when //path// points at a folder, {@link Error.NOTFOUND} when the file doesn't exist in any of HEAD, the index or the worktree, {@link Error.OK} otherwise
3340 */
3341 [CCode(cname = "git_status_file", instance_pos = 1.2)]
3342 public Error get_file_status(out Status status, string path);
3343
3344 /**
3345 * Retrieve and resolve the reference pointed at by HEAD.
3346 *
3347 * @param head the reference which will be retrieved
3348 */
3349 [CCode(cname = "git_repository_head", instance_pos = -1)]
3350 public Error get_head(out Reference head);
3351
3352 /**
3353 * Get the index file for this repository.
3354 *
3355 * If a custom index has not been set, the default
3356 * index for the repository will be returned (the one
3357 * located in //.git/index//).
3358 *
3359 * If a custom index has not been set, the default
3360 * index for the repository will be returned (the one
3361 * located in //.git/index//).
3362 *
3363 */
3364 [CCode(cname = "git_repository_index", instance_pos = -1)]
3365 public void get_index(out Index index);
3366
3367 /**
3368 * Get the information for a particular remote
3369 *
3370 * The name will be checked for validity.
3371 * @param remote the new remote object
3372 * @param name the remote's name
3373 * @see create_tag
3374 */
3375 [CCode(cname = "git_remote_load", instance_pos = 1.2)]
3376 public Error get_remote(out Remote remote, string name);
3377
3378 /**
3379 * Return the name of remote that the remote tracking branch belongs to.
3380 *
3381 * @param remote_name The buffer which will be filled with the name of the
3382 * remote. Pass null if you just want to get the needed size of the name of
3383 * the remote as the output value.
3384 *
3385 * @param canonical_branch_name name of the remote tracking branch.
3386 *
3387 * @return Number of characters in the reference name including the
3388 * trailing NUL byte; {@link Error.NOTFOUND} when no remote matching remote
3389 * was found, {@link Error.AMBIGUOUS} when the branch maps to several
3390 * remotes, otherwise an error code.
3391 */
3392 [CCode(cname = "git_branch_remote_name", insance_pos = 1.2)]
3393 public int get_branch_remote_name([CCode(array_length_type = "size_t")] uint8[]? remote_name, string canonical_branch_name);
3394
3395 /**
3396 * Get the Reference Database Backend for this repository.
3397 *
3398 * If a custom refsdb has not been set, the default database for the
3399 * repository will be returned (the one that manipulates loose and packed
3400 * references in the '''.git''' directory).
3401 */
3402 [CCode(cname = "git_repository_refdb", instance_pos = -1)]
3403 public Error get_refdb(out RefDb? refdb);
3404
3405 /**
3406 * Get a list of the configured remotes for a repo
3407 *
3408 * @param remotes_list a string array with the names of the remotes
3409 */
3410 [CCode(cname = "git_remote_list", instance_pos = -1)]
3411 public Error get_remote_list(out string_array remotes_list);
3412
3413 /**
3414 * Fill a list with all the tags in the Repository
3415 *
3416 * @param tag_names where the tag names will be stored
3417 */
3418 [CCode(cname = "git_tag_list", instance_pos = -1)]
3419 public Error get_tag_list(string_array tag_names);
3420
3421 /**
3422 * Fill a list with all the tags in the Repository which name match a
3423 * defined pattern
3424 *
3425 * If an empty pattern is provided, all the tags will be returned.
3426 *
3427 * @param tag_names the tag names will be stored
3428 * @param pattern standard shell-like (fnmatch) pattern
3429 */
3430 [CCode(cname = "git_tag_list_match", instance_pos = -1)]
3431 public Error get_tag_list_match(out string_array tag_names, string pattern);
3432
3433 /**
3434 * Return the name of the reference supporting the remote tracking branch,
3435 * given the name of a local branch reference.
3436 *
3437 * @param tracking_branch_name The buffer which will be filled with the
3438 * name of the reference, or null if you just want to get the needed size
3439 * of the name of the reference as the output value.
3440 *
3441 * @param canonical_branch_name name of the local branch.
3442 *
3443 * @return number of characters in the reference name including the
3444 * trailing NUL byte; otherwise an error code.
3445 */
3446 [CCode(cname = "git_branch_tracking_name", instance_pos = 1.3)]
3447 public int get_tracking_branch_name([CCode(array_length_type = "size_t")] char[]? tracking_branch_name, string canonical_branch_name);
3448
3449 /**
3450 * Allocate a new revision walker to iterate through a repo.
3451 *
3452 * This revision walker uses a custom memory pool and an internal commit
3453 * cache, so it is relatively expensive to allocate.
3454 *
3455 * For maximum performance, this revision walker should be reused for
3456 * different walks.
3457 *
3458 * This revision walker is ''not'' thread safe: it may only be used to walk
3459 * a repository on a single thread; however, it is possible to have several
3460 * revision walkers in several different threads walking the same
3461 * repository.
3462 *
3463 * @param walker the new revision walker
3464 */
3465 [CCode(cname = "git_revwalk_new", instance_pos = -1)]
3466 public Error get_walker(out RevisionWalker walker);
3467
3468 /**
3469 * Calculate hash of file using repository filtering rules.
3470 *
3471 * If you simply want to calculate the hash of a file on disk with no filters,
3472 * you can just use the {@link object_id.hashfile} API. However, if you
3473 * want to hash a file in the repository and you want to apply filtering
3474 * rules (e.g. crlf filters) before generating the SHA, then use this
3475 * function.
3476 *
3477 * @param path Path to file on disk whose contents should be hashed. This can be a relative path.
3478 * @param type The object type to hash
3479 * @param as_path The path to use to look up filtering rules. If this is
3480 * null, then the path parameter will be used instead. If this is passed as
3481 * the empty string, then no filters will be applied when calculating the
3482 * hash.
3483 */
3484 [CCode(cname = "git_repository_hashfile", instance_pos = 1.1)]
3485 public Error hashfile(out object_id id, string path, ObjectType type, string? as_path = null);
3486
3487 /**
3488 * Iterate over the branches in the repository.
3489 *
3490 * @param list_flags Filtering flags for the branch listing.
3491 */
3492 [CCode(cname = "git_branch_foreach")]
3493 public Error for_each_branch(BranchType list_flags, Branch branch);
3494 /**
3495 * Test if the ignore rules apply to a given path.
3496 *
3497 * This function checks the ignore rules to see if they would apply to the
3498 * given file. This indicates if the file would be ignored regardless of
3499 * whether the file is already in the index or commited to the repository.
3500 *
3501 * One way to think of this is if you were to do '''git add .''' on the
3502 * directory containing the file, would it be added or not?
3503 *
3504 * @param path the file to check ignores for, relative to the repo's
3505 * workdir.
3506 */
3507 [CCode(cname = "git_ignore_path_is_ignored", instance_pos = 1.1)]
3508 public Error is_path_ignored(out bool ignored, string path);
3509
3510 [CCode(cname = "git_branch_foreach", instance_pos = 1.2)]
3511 public Error list_branches(out string_array branch_names, BranchType list_flags);
3512
3513 /**
3514 * Fill a list with all the references that can be found
3515 * in a repository.
3516 *
3517 * The listed references may be filtered by type, or using
3518 * a bitwise OR of several types. Use the magic value
3519 * {@link ReferenceType.LISTALL} to obtain all references, including
3520 * packed ones.
3521 *
3522 * @param array where the reference names will be stored
3523 * @param list_flags Filtering flags for the reference listing.
3524 */
3525 [CCode(cname = "git_reference_listall", instance_pos = 1.2)]
3526 public Error list_all(out string_array array, ReferenceType list_flags);
3527
3528 /**
3529 * Convert a tree entry to the object it points too.
3530 *
3531 * @param object pointer to the converted object
3532 * @param entry a tree entry
3533 */
3534 [CCode(cname = "git_tree_entry_to_object", instance_pos = 1.2)]
3535 public Error load(out Object object, TreeEntry entry);
3536
3537 /**
3538 * Lookup a blob object from a repository.
3539 *
3540 * @param blob the looked up blob
3541 * @param id identity of the blob to locate.
3542 */
3543 [CCode(cname = "git_blob_lookup", instance_pos = 1.2)]
3544 public Error lookup_blob(out Blob blob, object_id id);
3545
3546 /**
3547 * Lookup a blob object from a repository, given a prefix of its identifier
3548 * (short id).
3549 *
3550 * @see lookup_object_by_prefix
3551 *
3552 * @param blob the looked up blob
3553 * @param id identity of the blob to locate.
3554 * @param len the length of the short identifier
3555 */
3556 [CCode(cname = "git_blob_lookup_prefix", instance_pos = 1.2)]
3557 public Error lookup_blob_by_prefix(out Blob blob, object_id id, size_t len);
3558 /**
3559 * Lookup a branch by its name.
3560 *
3561 * @param branch_name Name of the branch to be looked-up; this name is
3562 * validated for consistency.
3563 */
3564 [CCode(cname = "git_branch_lookup", instance_pos = 1.1)]
3565 public Error lookup_branch(out Reference? branch, string branch_name, BranchType branch_type);
3566
3567 /**
3568 * Lookup a commit object from a repository.
3569 *
3570 * @param commit the looked up commit
3571 * @param id identity of the commit to locate. If the object is an annotated tag it will be peeled back to the commit.
3572 */
3573 [CCode(cname = "git_commit_lookup", instance_pos = 1.2)]
3574 public Error lookup_commit(out Commit commit, object_id id);
3575
3576 /**
3577 * Lookup a commit object from a repository, given a prefix of its
3578 * identifier (short id).
3579 *
3580 * @see lookup_object_by_prefix
3581 *
3582 * @param commit the looked up commit
3583 * @param id identity of the commit to locate. If the object is an annotated tag it will be peeled back to the commit.
3584 * @param len the length of the short identifier
3585 */
3586 [CCode(cname = "git_commit_lookup_prefix", instance_pos = 1.2)]
3587 public Error lookup_commit_by_prefix(out Commit commit, object_id id, size_t len);
3588
3589 /**
3590 * Lookup a reference to one of the objects in a repostory.
3591 *
3592 * The //type// parameter must match the type of the object in the ODB; the
3593 * method will fail otherwise. The special value {@link ObjectType.ANY}
3594 * may be passed to let the method guess the object's type.
3595 *
3596 * @param object the looked-up object
3597 * @param id the unique identifier for the object
3598 * @param type the type of the object
3599 * @return a reference to the object
3600 */
3601 [CCode(cname = "git_object_lookup", instance_pos = 1.2)]
3602 public Error lookup_object(out Object object, object_id id, ObjectType type);
3603
3604 /**
3605 * Lookup a reference to one of the objects in a repostory, given a prefix
3606 * of its identifier (short id).
3607 *
3608 * The object obtained will be so that its identifier matches the first
3609 * //len// hexadecimal characters (packets of 4 bits) of the given //id//.
3610 * //len// must be at least {@link object_id.MIN_PREFIX_LENGTH}, and long
3611 * enough to identify a unique object matching the prefix; otherwise the
3612 * method will fail.
3613 *
3614 * The //type// parameter must match the type of the object in the ODB; the
3615 * method will fail otherwise. The special value {@link ObjectType.ANY}
3616 * may be passed to let the method guess the object's type.
3617 *
3618 * @param object where to store the looked-up object
3619 * @param id a short identifier for the object
3620 * @param len the length of the short identifier
3621 * @param type the type of the object
3622 */
3623 [CCode(cname = "git_object_lookup_prefix", instance_pos = 1.2)]
3624 public Error lookup_object_by_prefix(out Object object, object_id id, size_t len, ObjectType type);
3625
3626 /**
3627 * Lookup a reference by its name in a repository.
3628 *
3629 * @param reference the looked-up reference
3630 * @param name the long name for the reference (e.g., HEAD, ref/heads/master, refs/tags/v0.1.0, ...)
3631 */
3632 [CCode(cname = "git_reference_lookup", instance_pos = 1.2)]
3633 public Error lookup_reference(out Reference reference, string name);
3634
3635 /**
3636 * Lookup a reference by name and resolve immediately to an ID.
3637 *
3638 * @param name The long name for the reference
3639 */
3640 [CCode(cname = "git_reference_name_to_id", instance_pos = 1.2)]
3641 public Error lookup_reference_to_id(out object_id id, string name);
3642
3643 /**
3644 * Lookup submodule information by name or path.
3645 *
3646 * Given either the submodule name or path (they are ususally the same),
3647 * this returns a structure describing the submodule.
3648 *
3649 * @param name The name of the submodule. Trailing slashes will be ignored.
3650 */
3651 [CCode(cname = "git_submodule_lookup", instance_pos = 1.2)]
3652 public Error lookup_submodule(out unowned Submodule? submodule, string name);
3653
3654 /**
3655 * Lookup a tag object from the repository.
3656 *
3657 * @param tag pointer to the looked up tag
3658 * @param id identity of the tag to locate.
3659 */
3660 [CCode(cname = "git_tag_lookup", instance_pos = 1.2)]
3661 public Error lookup_tag(out Tag tag, object_id id);
3662
3663 /**
3664 * Lookup a tag object from the repository, given a prefix of its
3665 * identifier (short id).
3666 *
3667 * @see lookup_object_by_prefix
3668 *
3669 * @param tag pointer to the looked up tag
3670 * @param id identity of the tag to locate.
3671 * @param len the length of the short identifier
3672 */
3673 [CCode(cname = "git_tag_lookup_prefix", instance_pos = 1.2)]
3674 public Error prefix_lookup_tag(out Tag tag, object_id id, uint len);
3675
3676 /**
3677 * Lookup a tree object from the repository.
3678 *
3679 * @param tree the looked up tree
3680 * @param id identity of the tree to locate.
3681 */
3682 [CCode(cname = "git_tree_lookup", instance_pos = 1.2)]
3683 public Error lookup_tree(out Tree tree, object_id id);
3684
3685 /**
3686 * Lookup a tree object from the repository, given a prefix of its
3687 * identifier (short id).
3688 *
3689 * @see lookup_object_by_prefix
3690 *
3691 * @param tree the looked up tree
3692 * @param id identity of the tree to locate.
3693 * @param len the length of the short identifier
3694 */
3695 [CCode(cname = "git_tree_lookup_prefix", instance_pos = 1.2)]
3696 public Error lookup_tree_by_prefix(out Tree tree, object_id id, uint len);
3697
3698 /**
3699 * Create a new reference database and automatically add
3700 * the default backends:
3701 *
3702 * - git_refdb_dir: read and write loose and packed refs from disk,
3703 * assuming the repository dir as the folder
3704 */
3705 [CCode(cname = "git_refdb_open", instance_pos = -1)]
3706 public Error open_refdb(out RefDb? refdb);
3707
3708 /**
3709 * Find an object, as specified by a revision string. See the gitrevisions
3710 * manual page, or the documentation for '''git rev-parse''' for
3711 * information on the syntax accepted.
3712 *
3713 * @param spec the textual specification for an object
3714 */
3715 [CCode(cname = "git_revparse_single", instance_pos = 1.1)]
3716 public Error parse(out Object? obj, string spec);
3717
3718 /**
3719 * Read the note for an object
3720 * @param notes_ref ID reference to use (optional); defaults to "refs/notes/commits"
3721 * @param id ID of the object
3722 */
3723 [CCode(cname = "git_note_read", instance_pos = 1.2)]
3724 public Error read_note(out Note? note, string? notes_ref, object_id id);
3725 /**
3726 * Get the default notes reference for a repository
3727 */
3728 [CCode(cname = "git_note_default_ref", instance_pos = -1)]
3729 public Error read_note_default_ref(out unowned string note);
3730
3731 /**
3732 * Reread all submodule info.
3733 *
3734 * Call this to reload all cached submodule information for the repo.
3735 */
3736 [CCode(cname = "git_submodule_reload_all")]
3737 public Error reload_submodules();
3738
3739 /**
3740 * Remove the note for an object
3741 *
3742 * @param notes_ref ID reference to use (optional); defaults to "refs/notes/commits"
3743 * @param author signature of the notes commit author
3744 * @param committer signature of the notes commit committer
3745 * @param id the id which note's to be removed
3746 */
3747 [CCode(cname = "git_note_remove")]
3748 public Error remove_note(string? notes_ref, Signature author, Signature committer, object_id id);
3749
3750 /**
3751 * Sets the current head to the specified commit oid and optionally resets
3752 * the index and working tree to match.
3753 *
3754 * When specifying a Soft kind of reset, the head will be moved to the commit.
3755 *
3756 * Specifying a Mixed kind of reset will trigger a Soft reset and the index
3757 * will be replaced with the content of the commit tree.
3758 *
3759 * @param target Object to which the Head should be moved to. This object
3760 * must belong to this repository and can either be a {@link Commit} or a
3761 * {@link Tag}. When a {@link Tag} is being passed, it should be
3762 * dereferencable to a {@link Commit} which oid will be used as the target
3763 * of the branch.
3764 * @param reset_type Kind of reset operation to perform.
3765 */
3766 [CCode(cname = "git_reset")]
3767 public Error reset(Object target, ResetType reset_type);
3768
3769 /**
3770 * Updates some entries in the index from the target commit tree.
3771 *
3772 * The scope of the updated entries is determined by the paths
3773 * specified.
3774 *
3775 * @param target The committish which content will be used to reset the
3776 * content of the index. Passing null will result in removing entries in
3777 * the index matching the provided pathspecs.
3778 *
3779 * @param pathspecs List of pathspecs to operate on.
3780 */
3781 [CCode(cname = "git_reset_default")]
3782 public Error reset_default(Object? target, string_array pathspecs);
3783
3784 /**
3785 * Save the local modifications to a new stash.
3786 *
3787 * @param id id of the commit containing the stashed state. This commit is
3788 * also the target of the direct reference refs/stash.
3789 * @param stasher The identity of the person performing the stashing.
3790 * @param message description along with the stashed state.
3791 */
3792 [CCode(cname = "git_stash_save", instance_pos = 1.1)]
3793 public Error save_stash(out object_id id, Signature stasher, string? message = null, StashFlag flags = StashFlag.DEFAULT);
3794
3795 /**
3796 * Set the configuration file for this repository
3797 *
3798 * This configuration file will be used for all configuration
3799 * queries involving this repository.
3800 */
3801 [CCode(cname = "git_repository_set_config")]
3802 public void set_config(Config config);
3803
3804 /**
3805 * Set the Object Database for this repository
3806 *
3807 * The ODB will be used for all object-related operations involving this
3808 * repository.
3809 */
3810 [CCode(cname = "git_repository_set_odb")]
3811 public void set_db(Database.Handle db);
3812 /**
3813 * Make the repository HEAD point to the specified reference.
3814 *
3815 * If the provided reference points to a Tree or a Blob, the HEAD is
3816 * unaltered and an error is returned.
3817 *
3818 * If the provided reference points to a branch, the HEAD will point to
3819 * that branch, staying attached, or become attached if it isn't yet. If
3820 * the branch doesn't exist yet, no error will be return. The HEAD will
3821 * then be attached to an unborn branch.
3822 *
3823 * Otherwise, the HEAD will be detached and will directly point to the
3824 * Commit.
3825 *
3826 * @param refname Canonical name of the reference the HEAD should point at
3827 */
3828 [CCode(cname = "git_repository_set_head")]
3829 public Error set_head(string refname);
3830
3831 /**
3832 * Make the repository HEAD directly point to the Commit.
3833 *
3834 * If the provided committish cannot be found in the repository, the HEAD
3835 * is unaltered and {@link Error.NOTFOUND} is returned.
3836 *
3837 * If the provided commitish cannot be peeled into a commit, the HEAD is
3838 * unaltered and and error is returned.
3839 *
3840 * Otherwise, the HEAD will eventually be detached and will directly point to
3841 * the peeled Commit.
3842 *
3843 * @param commitish Object id of the Commit the HEAD should point to
3844 * @return 0 on success, or an error code
3845 */
3846 [CCode(cname = "git_repository_set_head_detached")]
3847 public Error set_head_detached(object_id commitish);
3848
3849 /**
3850 * Set the index file for this repository
3851 *
3852 * This index will be used for all index-related operations
3853 * involving this repository.
3854 */
3855 [CCode(cname = "git_repository_set_index")]
3856 public void set_index(Index index);
3857
3858 /**
3859 * Set the Reference Database Backend for this repository
3860 *
3861 * The refdb will be used for all reference related operations involving
3862 * this repository.
3863 */
3864 [CCode(cname = "git_repository_set_refdb")]
3865 public void set_refdb(RefDb refdb);
3866
3867 /**
3868 * Set the working directory.
3869 * @param workdir The path to a working directory
3870 * @param update_gitlink Create/update gitlink in workdir and set config
3871 * "core.worktree" (if workdir is not the parent of the .git directory)
3872 */
3873 [CCode(cname = "git_repository_set_workdir")]
3874 public Error set_workdir(string workdir, bool update_gitlink);
3875
3876 /**
3877 * Test if the ignore rules apply to a given file.
3878 *
3879 * This function simply checks the ignore rules to see if they would apply
3880 * to the given file. Unlike {@link get_file_status}, this indicates if
3881 * the file would be ignored regardless of whether the file is already in
3882 * the index or in the repository.
3883 *
3884 * @param path the file to check ignores for, rooted at the repo's workdir
3885 * @param ignored false if the file is not ignored, true if it is
3886 * @return {@link Error.OK} if the ignore rules could be processed
3887 * for the file (regardless of whether it exists or not), or an error if
3888 * they could not.
3889 */
3890 [CCode(cname = "git_status_should_ignore", instance_pos = 1.2)]
3891 public Error should_ignore(out bool ignored, string path);
3892
3893 /**
3894 * Write the contents of the tree builder as a tree object
3895 *
3896 * The tree builder will be written to the repositrory, and it's
3897 * identifying SHA1 hash will be stored in the id pointer.
3898 *
3899 * @param id Pointer where to store the written id
3900 * @param builder Tree builder to write
3901 */
3902 [CCode(cname = "git_treebuilder_write", instance_pos = 1.2)]
3903 public Error write(object_id id, TreeBuilder builder);
3904
3905 }
3906
3907 /**
3908 * An in-progress walk through the commits in a repo
3909 */
3910 [CCode(cname = "git_revwalk", free_function = "git_revwalk_free", has_type_id = false)]
3911 [Compact]
3912 public class RevisionWalker {
3913
3914 /**
3915 * The repository on which this walker is operating.
3916 */
3917 public Repository repository {
3918 [CCode(cname = "git_revwalk_repository")]
3919 get;
3920 }
3921
3922 /**
3923 * Mark a commit (and its ancestors) uninteresting for the output.
3924 *
3925 * The given id must belong to a commit on the walked repository.
3926 *
3927 * The resolved commit and all its parents will be hidden from the output
3928 * on the revision walk.
3929 *
3930 * @param id the id of commit that will be ignored during the traversal
3931 */
3932 [CCode(cname = "git_revwalk_hide")]
3933 public Error hide(object_id id);
3934
3935 /**
3936 * Hide the OID pointed to by a reference
3937 *
3938 * The reference must point to a commit.
3939 *
3940 * @param refname the referece to hide
3941 */
3942 [CCode(cname = "git_revwalk_hide_ref")]
3943 public Error hide_ref(string refname);
3944
3945 /**
3946 * Get the next commit from the revision walk.
3947 *
3948 * The initial call to this method is ''not'' blocking when iterating through
3949 * a repo with a time-sorting mode.
3950 *
3951 * Iterating with topological or inverted modes makes the initial call
3952 * blocking to preprocess the commit list, but this block should be mostly
3953 * unnoticeable on most repositories (topological preprocessing times at
3954 * 0.3s on the git.git repo).
3955 *
3956 * The revision walker is reset when the walk is over.
3957 *
3958 * @param id where to store the id of the next commit
3959 */
3960 [CCode(cname = "git_revwalk_next", instance_pos = -1)]
3961 public Error next(out object_id id);
3962
3963 /**
3964 * Mark a commit to start traversal from.
3965 *
3966 * The given id must belong to a commit on the walked repository.
3967 *
3968 * The given commit will be used as one of the roots when starting the
3969 * revision walk. At least one commit must be pushed the repository before
3970 * a walk can be started.
3971 *
3972 * @param id the id of the commit to start from.
3973 */
3974 [CCode(cname = "git_revwalk_push")]
3975 public Error push(object_id id);
3976
3977 /**
3978 * Push the OID pointed to by a reference
3979 *
3980 * The reference must point to a commit.
3981 *
3982 * @param refname the referece to push
3983 */
3984 [CCode(cname = "git_revwalk_push_ref")]
3985 public Error push_ref(string refname);
3986
3987 /**
3988 * Push matching references
3989 *
3990 * The OIDs pinted to by the references that match the given glob
3991 * pattern will be pushed to the revision walker.
3992 *
3993 * A leading 'refs/' is implied it not present as well as a trailing
3994 * '/ *' if the glob lacks '?', '*' or '['.
3995 *
3996 * @param glob the glob pattern references should match
3997 */
3998 [CCode(cname = "git_revwalk_push_glob")]
3999 public Error push_glob(string glob);
4000
4001 /**
4002 * Push the repository's HEAD
4003 */
4004 [CCode(cname = "git_revwalk_push_head")]
4005 public Error push_head();
4006
4007 /**
4008 * Reset the revision walker for reuse.
4009 *
4010 * This will clear all the pushed and hidden commits, and leave the walker
4011 * in a blank state (just like at creation) ready to receive new commit
4012 * pushes and start a new walk.
4013 *
4014 * The revision walk is automatically reset when a walk is over.
4015 */
4016 [CCode(cname = "git_revwalk_reset")]
4017 public void reset();
4018
4019 /**
4020 * Change the sorting mode when iterating through the repository's
4021 * contents.
4022 *
4023 * Changing the sorting mode resets the walker.
4024 *
4025 * @param sort combination of sort flags
4026 */
4027 [CCode(cname = "git_revwalk_sorting")]
4028 public void set_sorting(Sorting sort);
4029
4030 /**
4031 * Hide matching references.
4032 *
4033 * The OIDs pinted to by the references that match the given glob
4034 * pattern and their ancestors will be hidden from the output on the
4035 * revision walk.
4036 *
4037 * A leading 'refs/' is implied it not present as well as a trailing
4038 * '/ *' if the glob lacks '?', '*' or '['.
4039 *
4040 * @param glob the glob pattern references should match
4041 */
4042 [CCode(cname = "git_revwalk_hide_glob")]
4043 public Error hide_glob(string glob);
4044
4045 /**
4046 * Hide the repository's HEAD
4047 */
4048 [CCode(cname = "git_revwalk_hide_head")]
4049 public Error hide_head();
4050 }
4051
4052 /**
4053 * An action signature (e.g. for committers, taggers, etc)
4054 */
4055 [CCode(cname = "git_signature", free_function = "git_signature_free", copy_function = "git_signature_dup", has_type_id = false)]
4056 [Compact]
4057 public class Signature {
4058 /**
4059 * Email of the author
4060 */
4061 public string email;
4062 /**
4063 * Full name of the author
4064 */
4065 public string name;
4066 /**
4067 * Time when the action happened
4068 */
4069 public time when;
4070
4071 /**
4072 * Create a new action signature.
4073 *
4074 * Note: angle brackets characters are not allowed in either the name or
4075 * the email.
4076 * @param sig new signature, null in case of error
4077 * @param name name of the person
4078 * @param email email of the person
4079 * @param time time when the action happened
4080 * @param offset timezone offset in minutes for the time
4081 */
4082 [CCode(cname = "git_signature_new")]
4083 public static int create(out Signature? sig, string name, string email, int64 time, int offset);
4084
4085 /**
4086 * Create a new action signature with a timestamp of now.
4087 *
4088 * @param sig new signature, null in case of error
4089 * @param name name of the person
4090 * @param email email of the person
4091 */
4092 [CCode(cname = "git_signature_now")]
4093 public static int create_now(out Signature? sig, string name, string email);
4094 }
4095
4096 /**
4097 * Description of submodule
4098 *
4099 * This record describes a submodule found in a repository. There
4100 * should be an entry for every submodule found in the HEAD and for
4101 * every submodule described in .gitmodules.
4102 */
4103 [CCode(cname = "git_submodule", has_type_id = false)]
4104 [Compact]
4105 public class Submodule {
4106 /**
4107 * The name of the submodule from .gitmodules.
4108 */
4109 public string name {
4110 [CCode(cname = "git_submodule_name")]
4111 get;
4112 }
4113 /**
4114 * The path to the submodule from the repo working directory.
4115 *
4116 * It is almost always the same as {@link name}.
4117 */
4118 public string path {
4119 [CCode(cname = "git_submodule_path")]
4120 get;
4121 }
4122 /**
4123 * The url for the submodule.
4124 *
4125 * If deleted but not commited, this will be null.
4126 */
4127 public string? url {
4128 [CCode(cname = "git_submodule_url")]
4129 get;
4130 [CCode(cname = "git_submodule_set_url")]
4131 set;
4132 }
4133 /**
4134 * Get the OID for the submodule in the index.
4135 */
4136 public object_id? index_id {
4137 [CCode(cname = "git_submodule_index_id")]
4138 get;
4139 }
4140 /**
4141 * Get the OID for the submodule in the current HEAD tree.
4142 */
4143 public object_id? head_id {
4144 [CCode(cname = "git_submodule_head_id")]
4145 get;
4146 }
4147 /**
4148 * Whether or not to fetch submodules of submodules recursively.
4149 */
4150 public bool fetch_recurse {
4151 [CCode(cname = "git_submodule_fetch_recurse_submodules")]
4152 get;
4153 [CCode(cname = "git_submodule_set_fetch_recurse_submodules")]
4154 set;
4155 }
4156 /**
4157 * The containing repository for a submodule.
4158 *
4159 * This returns a pointer to the repository that contains the submodule.
4160 */
4161 public Repository repository {
4162 [CCode(cname = "git_submodule_owner")]
4163 get;
4164 }
4165
4166 /**
4167 * Get the OID for the submodule in the current working directory.
4168 *
4169 * This returns the OID that corresponds to looking up 'HEAD' in the
4170 * checked out submodule. If there are pending changes in the index or
4171 * anything else, this won't notice that. You should check
4172 * {@link status} for a more complete picture about the state of the
4173 * working directory.
4174 */
4175 public object_id? wd_id {
4176 [CCode(cname = "git_submodule_wd_id")]
4177 get;
4178 }
4179
4180 /**
4181 * The ignore rule for the submodule.
4182 */
4183 [CCode(cname = "git_submodule_ignore")]
4184 public SubmoduleIgnore ignore {
4185 [CCode(cname = "git_submodule_ignore")]
4186 get;
4187 [CCode(cname = "git_submodule_set_ignore")]
4188 set;
4189 }
4190
4191 /**
4192 * The update rule for the submodule.
4193 */
4194 public SubmoduleUpdate update {
4195 [CCode(cname = "git_submodule_update")]
4196 get;
4197 [CCode(cname = "git_submodule_set_update")]
4198 set;
4199 }
4200
4201 /**
4202 * Resolve the setup of a new git submodule.
4203 *
4204 * This should be called on a submodule once you have called add setup and
4205 * done the clone of the submodule. This adds the .gitmodules file and the
4206 * newly cloned submodule to the index to be ready to be committed (but
4207 * doesn't actually do the commit).
4208 */
4209 [CCode(cname = "git_submodule_add_finalize")]
4210 public Error add_finalize();
4211
4212 /**
4213 * Add current submodule HEAD commit to index of superproject.
4214 *
4215 * @param write_index if this should immediately write the index file. If
4216 * you pass this as false, you will have to explicitly call {@link Index.write}
4217 * on it to save the change.
4218 */
4219 [CCode(cname = "git_submodule_add_to_index")]
4220 public Error add_to_index(bool write_index);
4221
4222 /**
4223 * Copy submodule info into ".git/config" file.
4224 *
4225 * Just like "git submodule init", this copies information about the
4226 * submodule into ".git/config". You can use the accessor functions above
4227 * to alter the in-memory git_submodule object and control what is written
4228 * to the config, overriding what is in .gitmodules.
4229 *
4230 * @param overwrite By default, existing entries will not be overwritten,
4231 * but setting this to true forces them to be updated.
4232 */
4233 [CCode(cname = "git_submodule_init")]
4234 public Error init(bool overwrite);
4235
4236 /**
4237 * Get the locations of submodule information.
4238 *
4239 * This is a bit like a very lightweight version of {@link status}.
4240 * It just returns a made of the first four submodule status values (i.e.
4241 * the ones like {@link SubmoduleStatus.IN_HEAD}, etc) that tell you where
4242 * the submodule data comes from (i.e. the HEAD commit, gitmodules file,
4243 * etc.).
4244 *
4245 * This can be useful if you want to know if the submodule is present in
4246 * the working directory at this point in time, etc.
4247 */
4248 [CCode(cname = "git_submodule_location", instance_pos = -1)]
4249 public Error location(out SubmoduleStatus status);
4250
4251 /**
4252 * Copy submodule remote info into submodule repo.
4253 *
4254 * This copies the information about the submodules URL into the checked
4255 * out submodule config, acting like "git submodule sync". This is useful
4256 * if you have altered the URL for the submodule (or it has been altered by
4257 * a fetch of upstream changes) and you need to update your local repo.
4258 */
4259 [CCode(cname = "git_submodule_sync")]
4260 public Error sync();
4261
4262 /**
4263 * Open the repository for a submodule.
4264 *
4265 * This will only work if the submodule is checked out into the working
4266 * directory.
4267 */
4268 [CCode(cname = "git_submodule_open", instance_pos = -1)]
4269 public Error open(out Repository? repo);
4270
4271 /**
4272 * Reread submodule info from config, index, and HEAD.
4273 *
4274 * Call this to reread cached submodule information for this submodule if
4275 * you have reason to believe that it has changed.
4276 */
4277 [CCode(cname = "git_submodule_reload")]
4278 public Error reload();
4279
4280 /**
4281 * Write submodule settings to .gitmodules file.
4282 *
4283 * This commits any in-memory changes to the submodule to the gitmodules
4284 * file on disk. You may also be interested in `git_submodule_init()`
4285 * which writes submodule info to ".git/config" (which is better for local
4286 * changes to submodule settings) and/or `git_submodule_sync()` which
4287 * writes settings about remotes to the actual submodule repository.
4288 */
4289 [CCode(cname = "git_submodule_save")]
4290 public Error save();
4291
4292 /**
4293 * Get the status for a submodule.
4294 *
4295 * This looks at a submodule and tries to determine the status.
4296 */
4297 [CCode(cname = "git_submodule_status", instance_pos = -1)]
4298 public Error status(out SubmoduleStatus status);
4299 }
4300
4301 /**
4302 * Parsed representation of a tag object.
4303 */
4304 [CCode(cname = "git_tag", free_function = "git_tag_free", has_type_id = false)]
4305 [Compact]
4306 public class Tag : Object {
4307 /**
4308 * The id of a tag.
4309 */
4310 public object_id? id {
4311 [CCode(cname = "git_tag_id")]
4312 get;
4313 }
4314
4315 /**
4316 * The message of a tag
4317 */
4318 public string message {
4319 [CCode(cname = "git_tag_message")]
4320 get;
4321 }
4322
4323 /**
4324 * The name of a tag
4325 */
4326 public string name {
4327 [CCode(cname = "git_tag_name")]
4328 get;
4329 }
4330
4331 /**
4332 * The tagger (author) of a tag
4333 */
4334 public Signature tagger {
4335 [CCode(cname = "git_tag_tagger")]
4336 get;
4337 }
4338
4339 /**
4340 * The id of the tagged object of a tag
4341 */
4342 public object_id? target_id {
4343 [CCode(cname = "git_tag_target_id")]
4344 get;
4345 }
4346
4347 /**
4348 * The type of a tag's tagged object
4349 */
4350 public ObjectType target_type {
4351 [CCode(cname = "git_tag_target_type")]
4352 get;
4353 }
4354
4355 /**
4356 * Get the tagged object of a tag
4357 *
4358 * This method performs a repository lookup for the given object and
4359 * returns it
4360 *
4361 * @param target where to store the target
4362 */
4363 [CCode(cname = "git_tag_target", instance_pos = -1)]
4364 public Error lookup_target(out Object target);
4365
4366 /**
4367 * Recursively peel a tag until a non-tag-object is met
4368 */
4369 [CCode(cname = "git_tag_peel", instance_pos = -1)]
4370 public Error peel(out Object result);
4371 }
4372
4373 /**
4374 * Representation of a tree object.
4375 */
4376 [CCode(cname = "git_tree", free_function = "git_tree_free", has_type_id = false)]
4377 [Compact]
4378 public class Tree : Object {
4379 /**
4380 * The id of a tree.
4381 */
4382 public object_id? id {
4383 [CCode(cname = "git_tree_id")]
4384 get;
4385 }
4386
4387 public Repository repository {
4388 [CCode(cname = "git_tree_owner")]
4389 get;
4390 }
4391
4392 /**
4393 * Get the number of entries listed in a tree
4394 */
4395 public size_t size {
4396 [CCode(cname = "git_tree_entrycount")]
4397 get;
4398 }
4399
4400 /**
4401 * Lookup a tree entry by its position in the tree
4402 *
4403 * @param idx the position in the entry list
4404 * @return the tree entry; null if not found
4405 */
4406 [CCode(cname = "git_tree_entry_byindex")]
4407 public unowned TreeEntry? get(size_t idx);
4408 /**
4409 * Lookup a tree entry by SHA value.
4410 *
4411 * Warning: this must examine every entry in the tree, so it is not fast.
4412 *
4413 * @param id the sha being looked for
4414 * @return the tree entry; null if not found
4415 */
4416 [CCode(cname = "git_tree_entry_byoid")]
4417 public unowned TreeEntry? get_by_id(object_id id);
4418
4419 /**
4420 * Lookup a tree entry by its filename
4421 *
4422 * @param filename the filename of the desired entry
4423 * @return the tree entry; null if not found
4424 */
4425 [CCode(cname = "git_tree_entry_byname")]
4426 public unowned TreeEntry? get_by_name(string filename);
4427
4428 /**
4429 * Retrieve a subtree contained in a tree, given its relative path.
4430 *
4431 * @param path Path to the tree entry from which to extract the last tree object
4432 * @return {@link Error.OK} on success; {@link Error.NOTFOUND} if the path does not lead to an entry; otherwise, an error code
4433 */
4434 [CCode(cname = "git_tree_entry_bypath", instance_pos = 1.2)]
4435 public Error get_by_path(out TreeEntry entry, string path);
4436
4437 /**
4438 * Traverse the entries in a tree and its subtrees in post or pre order
4439 *
4440 * The entries will be traversed in the specified order, children subtrees
4441 * will be automatically loaded as required, and the callback will be
4442 * called once per entry with the current (relative) root for the entry and
4443 * the entry data itself.
4444 *
4445 * If the callback returns a negative value, the passed entry will be
4446 * skiped on the traversal.
4447 *
4448 * @param mode Traversal mode (pre or post-order)
4449 * @param tree_walker Function to call on each tree entry
4450 */
4451 [CCode(cname = "git_tree_walk")]
4452 public Error walk(WalkMode mode, TreeWalker tree_walker);
4453 }
4454
4455 /**
4456 * Constructor for in-memory trees
4457 */
4458 [CCode(cname = "git_treebuilder", free_function = "git_treebuilder_free", has_type_id = false)]
4459 [Compact]
4460 public class TreeBuilder {
4461 /**
4462 * The number of entries listed in a treebuilder.
4463 */
4464 public uint size {
4465 [CCode(cname = "git_treebuilder_entrycount")]
4466 get;
4467 }
4468
4469 /**
4470 * Create a new tree builder.
4471 *
4472 * The tree builder can be used to create or modify trees in memory and
4473 * write them as tree objects to the database.
4474 *
4475 * If the source parameter is not null, the tree builder will be
4476 * initialized with the entries of the given tree.
4477 *
4478 * If the source parameter is null, the tree builder will have no entries
4479 * and will have to be filled manually.
4480 *
4481 * @param builder where to store the tree builder
4482 * @param source source tree to initialize the builder (optional)
4483 */
4484 [CCode(cname = "git_treebuilder_create")]
4485 public static Error create(out TreeBuilder builder, Tree? source = null);
4486
4487 /**
4488 * Clear all the entires in the builder
4489 */
4490 [CCode(cname = "git_treebuilder_clear")]
4491 public void clear();
4492
4493 /**
4494 * Filter the entries in the tree
4495 *
4496 * The filter will be called for each entry in the tree with an entry. If
4497 * the callback returns true, the entry will be filtered (removed from the
4498 * builder).
4499 * @param filter function to filter entries
4500 */
4501 [CCode(cname = "git_treebuilder_filter")]
4502 public void filter(Filter filter);
4503
4504 /**
4505 * Add or update an entry to the builder
4506 *
4507 * Insert a new entry for the given filename in the builder with the given
4508 * attributes.
4509 *
4510 * If an entry named filename already exists, its attributes will be
4511 * updated with the given ones.
4512 *
4513 * @param entry where to store the entry (optional)
4514 * @param filename Filename of the entry
4515 * @param id SHA1 id of the entry
4516 * @param attributes Folder attributes of the entry
4517 * @return 0 on success; error code otherwise
4518 */
4519 [CCode(cname = "git_treebuilder_insert", instance_pos = 1.2)]
4520 public Error insert(out unowned TreeEntry? entry = null, string filename, object_id id, Attributes attributes);
4521
4522 /**
4523 * Get an entry from the builder from its filename
4524 * @param filename Name of the entry
4525 * @return the entry; null if not found
4526 */
4527 [CCode(cname = "git_treebuilder_get")]
4528 public unowned TreeEntry? get(string filename);
4529
4530 /**
4531 * Remove an entry from the builder by its filename
4532 *
4533 * @param filename Filename of the entry to remove
4534 */
4535 [CCode(cname = "git_treebuilder_remove")]
4536 public Error remove(string filename);
4537 }
4538
4539 /**
4540 * Representation of each one of the entries in a tree object.
4541 */
4542 [CCode(cname = "git_tree_entry", has_type_id = false, free_function = "git_tree_entry_free", copy_function = "git_tree_entry_dup")]
4543 [Compact]
4544 public class TreeEntry {
4545
4546 /**
4547 * The id of the object pointed by the entry
4548 */
4549 public unowned object_id? id {
4550 [CCode(cname = "git_tree_entry_id")]
4551 get;
4552 }
4553
4554 /**
4555 * The filename of a tree entry
4556 */
4557 public string name {
4558 [CCode(cname = "git_tree_entry_name")]
4559 get;
4560 }
4561
4562 /**
4563 * The UNIX file attributes of a tree entry
4564 */
4565 public FileMode mode {
4566 [CCode(cname = "git_tree_entry_filemode")]
4567 get;
4568 }
4569
4570 /**
4571 * The type of the object pointed by the entry
4572 */
4573 public ObjectType type {
4574 [CCode(cname = "git_tree_entry_type")]
4575 get;
4576 }
4577 /**
4578 * Compare two tree entries
4579 *
4580 * @param that second tree entry
4581 * @return <0 if this is before that, 0 if this == that, >0 if this is after that
4582 */
4583 [CCode(cname = "git_tree_entry_cmp")]
4584 public int cmp(TreeEntry that);
4585
4586 /**
4587 * Create a new tree builder.
4588 *
4589 * The tree builder can be used to create or modify trees in memory and
4590 * write them as tree objects to the database.
4591 *
4592 * The tree builder will be initialized with the entries of the given tree.
4593 *
4594 * @param builder where to store the tree builder
4595 */
4596 [CCode(cname = "git_treebuilder_create", instance_pos = -1)]
4597 public Error create_builder(out TreeBuilder builder);
4598 /**
4599 * Create a copy of a tree entry.
4600 */
4601 [CCode(cname = "git_tree_entry_dup")]
4602 public TreeEntry dup();
4603 }
4604
4605 /**
4606 * List of unmerged index entries
4607 */
4608 [CCode(cname = "git_index", has_type_id = false)]
4609 [Compact]
4610 public class ReucIndex {
4611 /**
4612 * The count of unmerged entries currently in the index
4613 */
4614 public uint size {
4615 [CCode(cname = "git_index_reuc_entrycount")]
4616 get;
4617 }
4618 /**
4619 * Adds a resolve undo entry for a file based on the given parameters.
4620 *
4621 * The resolve undo entry contains the OIDs of files that were involved in
4622 * a merge conflict after the conflict has been resolved. This allows
4623 * conflicts to be re-resolved later.
4624 *
4625 * If there exists a resolve undo entry for the given path in the index, it
4626 * will be removed.
4627 *
4628 * This method will fail in bare index instances.
4629 *
4630 * @param path filename to add
4631 * @param ancestor_mode mode of the ancestor file
4632 * @param ancestor_id oid of the ancestor file
4633 * @param our_mode mode of our file
4634 * @param our_id oid of our file
4635 * @param their_mode mode of their file
4636 * @param their_id oid of their file
4637 */
4638 [CCode(cname = "git_index_reuc_add")]
4639 public Error add(string path, FileMode ancestor_mode, object_id ancestor_id, FileMode our_mode, object_id our_id, FileMode their_mode, object_id their_id);
4640
4641 /**
4642 * Remove all resolve undo entries from the index
4643 */
4644 [CCode(cname = "git_index_reuc_clear")]
4645 public void clear();
4646
4647 /**
4648 * Finds the resolve undo entry that points to the given path in the Git
4649 * index.
4650 *
4651 * @param path path to search
4652 * @return an index >= 0 if found, -1 otherwise
4653 */
4654 [CCode(cname = "git_index_reuc_find")]
4655 public Error find(string path);
4656
4657 /**
4658 * Get an unmerged entry from the index.
4659 *
4660 * @param n the position of the entry
4661 * @return a pointer to the unmerged entry; null if out of bounds
4662 */
4663 [CCode(cname = "git_index_reuc_get_byindex")]
4664 public unowned index_reuc_entry? get(uint n);
4665
4666 /**
4667 * Get an unmerged entry from the index.
4668 *
4669 * @param path path to search
4670 * @return the unmerged entry; null if not found
4671 */
4672 [CCode(cname = "git_index_reuc_get_bypath")]
4673 public unowned index_reuc_entry? get_by_path(string path);
4674
4675 /**
4676 * Remove an resolve undo entry from the index
4677 *
4678 * @param n position of the resolve undo entry to remove
4679 */
4680 [CCode(cname = "git_index_reuc_remove")]
4681 public Error remove(size_t n);
4682 }
4683 [CCode(cname = "git_checkout_opts", has_type_id = false, default_value = "GIT_CHECKOUT_OPTS_INIT")]
4684 public struct checkout_opts {
4685 [CCode(cname = "GIT_CHECKOUT_OPTS_VERSION")]
4686 public const uint VERSION;
4687
4688 public uint version;
4689 public unowned CheckoutStategy checkout_strategy;
4690 public bool disable_filters;
4691 /**
4692 * Directory mode.
4693 *
4694 * If set to 0, the default is 0755 used.
4695 */
4696 public int dir_mode;
4697 /**
4698 * File mode.
4699 *
4700 * If set to 0, the default is 0644 is used.
4701 */
4702 public int file_mode;
4703 /**
4704 * File open(3) flags.
4705 *
4706 * If set to 0, the default is O_CREAT | O_TRUNC | O_WRONLY is used.
4707 */
4708 public int file_open_flags;
4709 public CheckoutNotify notify_flags;
4710 [CCode(cname = "notify_cb", delegate_target_cname = "notify_payload")]
4711 public unowned CheckoutNotify? notify;
4712
4713 /**
4714 * Notify the consumer of checkout progress.
4715 */
4716 [CCode(cname = "progress_cb", delegate_target_cname = "progress_payload")]
4717 public unowned Progress? progress;
4718
4719 /**
4720 * When not null, arrays of fnmatch pattern specifying which paths should be taken into account
4721 */
4722 public string_array paths;
4723 /**
4724 * Expected content of workdir, defaults to HEAD
4725 */
4726 public unowned Tree? baseline;
4727 }
4728
4729 [CCode(cname = "git_config_entry", has_type_id = false)]
4730 public struct config_entry{
4731 public string name;
4732 public string @value;
4733 public ConfigLevel level;
4734 }
4735
4736 /**
4737 * Clone options structure
4738 */
4739 [CCode(cname = "git_clone_options", has_type_id = false, default_value = "GIT_CLONE_OPTIONS_INIT")]
4740 public struct clone_opts {
4741 [CCode(cname = "GIT_CLONE_OPTIONS_VERSION")]
4742 public const uint VERSION;
4743 public uint version;
4744 public checkout_opts checkout_opts;
4745 /**
4746 * False to create a standard repo, true for a bare repo.
4747 */
4748 public bool bare;
4749 [CCode(cname = "fetch_progress_cb", delegate_target_cname = "fetch_progress_payload")]
4750 public unowned TransferProgress? fetch_progress;
4751
4752 /**
4753 * The name given to the "origin" remote.
4754 *
4755 * The default is "origin".
4756 */
4757 public string? remote_name;
4758 /**
4759 * The URL to be used for pushing.
4760 *
4761 * If unset, the fetch URL will be used.
4762 */
4763 public string? pushurl;
4764 /**
4765 * The fetch specification to be used for fetching.
4766 *
4767 * If unset, "+refs/heads/ *:refs/remotes/<remote_name>/ *"
4768 */
4769 public string? fetch_spec;
4770 /**
4771 * The fetch specification to be used for pushing.
4772 *
4773 * If unset, the same spec as for fetching.
4774 */
4775 public string? push_spec;
4776 /**
4777 * Callback to be used if credentials are required during the initial
4778 * fetch.
4779 */
4780 [CCode(cname = "git_cred_acquire_cb", delegate_target_cname = "cred_acquire_payload")]
4781 public unowned CredAcquire cred_acquire;
4782 /**
4783 * A custom transport to be used for the initial fetch.
4784 *
4785 * If unset, the transport autodetected from the URL.
4786 */
4787 public unowned transport? transport;
4788 /**
4789 * May be used to specify custom progress callbacks for the origin remote
4790 * before the fetch is initiated.
4791 */
4792 public unowned remote_callbacks? remote_callbacks;
4793 /**
4794 * May be used to specify the autotag setting before the initial fetch.
4795 */
4796 AutoTag remote_autotag;
4797 /**
4798 * Gives the name of the branch to checkout.
4799 *
4800 * If unset, use the remote's HEAD.
4801 */
4802 public string? checkout_branch;
4803 }
4804
4805 [CCode(cname = "git_cvar_map", has_type_id = false)]
4806 public struct config_var_map {
4807 public ConfigVar cvar_type;
4808 public string? str_match;
4809 public int map_value;
4810 }
4811 [CCode(cname = "git_cred")]
4812 public struct cred {
4813 public CredTypes credtype;
4814 public CredFree free;
4815
4816 /**
4817 * Creates a new plain-text username and password credential object.
4818 *
4819 * @param username The username of the credential.
4820 * @param password The password of the credential.
4821 */
4822 [CCode(cname = "git_cred_userpass_plaintext_new")]
4823 public static Error create_userpass_plaintext(out cred? cred, string username, string password);
4824 }
4825 [CCode(cname = "git_cred_userpass_payload", has_type_id = false)]
4826 public struct cred_userpass {
4827 public string username;
4828 public string password;
4829 /**
4830 * Method usable as {@link CredAcquire}.
4831 *
4832 * This calls {@link cred.create_userpass_plaintext} unless the protocol
4833 * has not specified {@link CredTypes.USERPASS_PLAINTEXT} as an allowed
4834 * type.
4835 *
4836 * @param cred The newly created credential object.
4837 * @param url The resource for which we are demanding a credential.
4838 * @param username_from_url The username that was embedded in a "user@host"
4839 * remote url, or null if not included.
4840 */
4841 [CCode(cname = "git_cred_userpass", instance_pos = -1)]
4842 public Error acquire(out cred? cred, string url, string? username_from_url, CredTypes allowed_types);
4843 }
4844
4845 /**
4846 * Description of changes to one entry.
4847 *
4848 * When iterating over a diff list object, this will be passed to most
4849 * callback functions and you can use the contents to understand exactly what
4850 * has changed.
4851 *
4852 * The {@link diff_delta.old_file} repesents the "from" side of the diff and
4853 * the {@link diff_delta.new_file} repesents to "to" side of the diff. What
4854 * those means depend on the function that was used to generate the diff and
4855 * will be documented below. You can also use the {@link DiffFlags.REVERSE}
4856 * flag to flip it around.
4857 *
4858 * Although the two sides of the delta are named "old_file" and "new_file",
4859 * they actually may correspond to entries that represent a file, a symbolic
4860 * link, a submodule commit id, or even a tree (if you are tracking type
4861 * changes or ignored/untracked directories).
4862 *
4863 * Under some circumstances, in the name of efficiency, not all fields will
4864 * be filled in, but we generally try to fill in as much as possible.
4865 */
4866 [CCode(cname = "git_diff_delta", has_type_id = false)]
4867 public struct diff_delta {
4868 public diff_file old_file;
4869 public diff_file new_file;
4870 public DeltaType status;
4871 /**
4872 * For RENAMED and COPIED, value 0-100
4873 */
4874 public uint similarity;
4875 public DiffFlag flags;
4876 }
4877
4878 /**
4879 * Description of one side of a diff.
4880 * Although this is called a "file", it may actually represent a file, a
4881 * symbolic link, a submodule commit id, or even a tree (although that only
4882 * if you are tracking type changes or ignored/untracked directories).
4883 *
4884
4885 */
4886 [CCode(cname = "git_diff_file", has_type_id = false)]
4887 public struct diff_file {
4888 /**
4889 * The object id.
4890 *
4891 * If the entry represents an absent side of a diff (e.g., the {@link diff_delta.old_file}
4892 * of a {@link DeltaType.ADDED} delta), then the oid will be zeroes.
4893 */
4894 [CCode(cname = "oid")]
4895 public object_id id;
4896 /**
4897 * The path to the entry relative to the working directory of the
4898 * repository.
4899 */
4900 public string path;
4901 public FileMode mode;
4902 /**
4903 * The size of the entry in bytes.
4904 */
4905 public int size;
4906 public DiffFlag flags;
4907 }
4908
4909 /**
4910 * Structure describing options about how the diff should be executed.
4911 *
4912 * Setting all values of the structure to zero will yield the default
4913 * values. Similarly, passing NULL for the options structure will
4914 * give the defaults. The default values are marked below.
4915 *
4916 * Most of the parameters here are not actually supported at this time.
4917 */
4918 [CCode(cname = "git_diff_options", has_type_id = false, default_value = "GIT_DIFF_OPTIONS_INIT")]
4919 public struct diff_options {
4920 [CCode(cname = "GIT_DIFF_OPTIONS_VERSION")]
4921 public const uint VERSION;
4922 /**
4923 * Version for the struct
4924 */
4925 public uint version;
4926 public DiffFlags flags;
4927 /**
4928 * Number of lines of context to show around diffs
4929 */
4930 public uint16 context_lines;
4931 /**
4932 * Min lines between diff hunks to merge them
4933 */
4934 public uint16 interhunk_lines;
4935 /**
4936 * "Directory" to prefix to old file names (default "a")
4937 */
4938 public string? old_prefix;
4939 /**
4940 * "Directory" to prefix to new file names (default "b")
4941 */
4942 public string? new_prefix;
4943 /**
4944 * Array of paths / patterns to constrain diff
4945 *
4946 * Defaults to all paths
4947 */
4948 public string_array pathspec;
4949 /**
4950 * Maximum blob size to diff, above this treated as binary
4951 *
4952 * Defaults to 512 MB.
4953 */
4954 public uint64 max_size;
4955 }
4956
4957 /**
4958 * Structure describing a hunk of a diff.
4959 */
4960 [CCode(cname = "git_diff_range", has_type_id = false)]
4961 public struct diff_range {
4962 public int old_start;
4963 public int old_lines;
4964 public int new_start;
4965 public int new_lines;
4966 }
4967
4968 [CCode(cname = "git_diff_find_options", has_type_id = false, default_value = "GIT_DIFF_FIND_OPTIONS_INIT ")]
4969 public struct find_options {
4970 [CCode(cname = "GIT_DIFF_FIND_OPTIONS_VERSION")]
4971 public const uint VERSION;
4972 public uint version;
4973 public DiffFind flags;
4974 /**
4975 * Similarity to consider a file renamed (default 50)
4976 */
4977 public uint rename_threshold;
4978 /**
4979 * Similarity of modified to be eligible rename source (default 50)
4980 */
4981 public uint rename_from_rewrite_threshold;
4982 /**
4983 * Similarity to consider a file a copy (default 50)
4984 */
4985 public uint copy_threshold;
4986 /**
4987 * Similarity to split modify into delete/add pair (default 60)
4988 */
4989 public uint break_rewrite_threshold;
4990 /**
4991 * Maximum similarity sources to examine (e.g., diff's '''-l''' option or
4992 * the '''diff.renameLimit''' config) (default 200)
4993 */
4994 public uint target_limit;
4995 }
4996
4997 /**
4998 * Time used in a index entry
4999 */
5000 [CCode(cname = "git_index_time", has_type_id = false)]
5001 public struct index_time {
5002 public int64 seconds;
5003 public uint nanoseconds;
5004 }
5005
5006 /**
5007 * A resolve undo entry in the index.
5008 */
5009 [CCode(cname = "git_index_reuc_entry", has_type_id = false)]
5010 public struct index_reuc_entry {
5011 uint mode[3];
5012 [CCode(cname = "oid")]
5013 public object_id id[3];
5014 public string path;
5015 }
5016
5017 /**
5018 * Extended options structure for {@link Repository.init_ext}.
5019 *
5020 * This contains extra options that enable additional initialization
5021 * features.
5022 */
5023 [CCode(cname = "git_repository_init_options", has_type_id = false, default_value = "GIT_REPOSITORY_INIT_OPTIONS_INIT")]
5024 public struct init_options {
5025 /**
5026 * Use permissions configured by umask - the default.
5027 */
5028 [CCode(cname = "GIT_REPOSITORY_INIT_SHARED_UMASK")]
5029 public const uint32 MODE_SHARED_UMASK;
5030 /**
5031 * Use '''--shared=group''' behavior, chmod'ing the new repo to be group
5032 * writable and "g+sx" for sticky group assignment.
5033 */
5034 [CCode(cname = "GIT_REPOSITORY_INIT_SHARED_GROUP")]
5035 public const uint32 MODE_SHARED_GROUP;
5036 /**
5037 * Use '''--shared=all''' behavior, adding world readability.
5038 */
5039 [CCode(cname = "GIT_REPOSITORY_INIT_SHARED_ALL")]
5040 public const uint32 MODE_SHARED_ALL;
5041 [CCode(cname = "GIT_REPOSITORY_INIT_OPTIONS_VERSION")]
5042 public const uint VERSION;
5043 public uint version;
5044 public InitFlag flags;
5045 /**
5046 * The UNIX file mode.
5047 *
5048 * The standard values are {@link MODE_SHARED_UMASK},
5049 * {@link MODE_SHARED_GROUP}, or {@link MODE_SHARED_ALL}, but a custom
5050 * value may be used instead.
5051 */
5052 public uint32 mode;
5053 /**
5054 * The path to the working dir or null for default (i.e., the repoistory
5055 * path's parent on non-bare repos).
5056 *
5057 * If this is relative path, it will be evaluated relative to the
5058 * repository path.
5059 *
5060 * If this is not the natural working directory, a .git gitlink file will
5061 * be created here linking to the repoitory path.
5062 */
5063 public string? workdir_path;
5064 /**
5065 * If set, this will be used to initialize the '''description''' file in
5066 * the repository, instead of using the template content.
5067 */
5068 public string? description;
5069 /**
5070 * When {@link InitFlag.EXTERNAL_TEMPLATE} is set, this contains the path
5071 * to use for the template directory.
5072 *
5073 * If this is null, the config or default directory options will be used
5074 * instead.
5075 */
5076 public string? template_path;
5077 /**
5078 * The name of the head to point HEAD at. If null, then this will be
5079 * treated as '''master''' and the HEAD ref will be set to
5080 * '''refs/heads/master'''. If this begins with '''refs/''' it will be
5081 * used verbatim; otherwise '''refs/heads/''' will be prefixed.
5082 */
5083 public string? initial_head;
5084 /**
5085 * If this is non-null, then after the rest of the repository
5086 * initialization is completed, an '''origin''' remote will be added
5087 * pointing to this URL.
5088 */
5089 public string? origin_url;
5090 }
5091
5092 /**
5093 * Unique identity of any object (commit, tree, blob, tag).
5094 */
5095 [CCode(cname = "git_oid", has_type_id = false)]
5096 public struct object_id {
5097 /**
5098 * Raw binary formatted id
5099 */
5100 uint8 id[20];
5101
5102 [CCode(cname = "GIT_OID_HEX_ZERO")]
5103 public const string HEX_ZERO;
5104
5105 /**
5106 * Size (in bytes) of a raw/binary id
5107 */
5108 [CCode(cname = "GIT_OID_RAWSZ")]
5109 public const int RAW_SIZE;
5110
5111 /**
5112 * Size (in bytes) of a hex formatted id
5113 */
5114 [CCode(cname = "GIT_OID_HEXSZ")]
5115 public const int HEX_SIZE;
5116
5117 /**
5118 * Minimum length (in number of hex characters,
5119 * (i.e., packets of 4 bits) of an id prefix
5120 */
5121 [CCode(cname = "GIT_OID_MINPREFIXLEN")]
5122 public const int MIN_PREFIX_LENGTH;
5123
5124 /**
5125 * Parse a hex formatted null-terminated string.
5126 *
5127 * @param id id structure the result is written into.
5128 * @param str input hex string; must be at least 4 characters long.
5129 */
5130 [CCode(cname = "git_oid_fromstrp")]
5131 public static Error from_string(out object_id id, string str);
5132
5133 /**
5134 * Parse a hex formatted object id
5135 *
5136 * @param id id structure the result is written into.
5137 * @param str input hex string; must be pointing at the start of the hex
5138 * sequence and have at least the number of bytes needed for an id encoded
5139 * in hex (40 bytes).
5140 * @return {@link Error.OK} if valid, {@link Error.NOTID} on failure.
5141 */
5142 [CCode(cname = "git_oid_fromstr")]
5143 public static Error from_string_exact(out object_id id, string str);
5144
5145 /**
5146 * Parse N characters of a hex formatted object id
5147 *
5148 * If N is odd, N-1 characters will be parsed instead.
5149 * The remaining space in the git_oid will be set to zero.
5150 *
5151 * @param id id structure the result is written into.
5152 * @param data input hex string
5153 * @return {@link Error.OK} if valid.
5154 */
5155 [CCode(cname = "git_oid_fromstrn")]
5156 public static Error from_array(out object_id id, [CCode(array_length_type = "size_t")] uint8[] data);
5157
5158 /**
5159 * Copy an already raw id
5160 */
5161 [CCode(cname = "git_oid_fromraw")]
5162 public static void from_raw(out object_id id, [CCode(array_length = false)] uint8[] raw);
5163
5164 /**
5165 * Format an id into a hex string.
5166 *
5167 * @param str output hex string; must be pointing at the start of the hex
5168 * sequence and have at least the number of bytes needed for an id encoded
5169 * in hex (40 bytes). Only the id digits are written; a nul terminator must
5170 * be added by the caller if it is required.
5171 */
5172 [CCode(cname = "git_oid_fmt", instance_pos = -1)]
5173 public void to_buffer([CCode(array_length = false)] char[] str);
5174
5175 /**
5176 * Format an id into a loose-object path string.
5177 *
5178 * The resulting string is "aa/...", where "aa" is the first two
5179 * hex digitis of the id and "..." is the remaining 38 digits.
5180 *
5181 * @param str output hex string; must be pointing at the start of the hex
5182 * sequence and have at least the number of bytes needed for an oid encoded
5183 * in hex (41 bytes). Only the id digits are written; a nul terminator
5184 * must be added by the caller if it is required.
5185 */
5186 [CCode(cname = "git_oid_pathfmt", instance_pos = -1)]
5187 public void to_path([CCode(array_length = false)] char[] str);
5188
5189 /**
5190 * Format an id into a string.
5191 *
5192 * @return the string; null if memory is exhausted.
5193 */
5194 [CCode(cname = "git_oid_allocfmt")]
5195 public string? to_string();
5196
5197 /**
5198 * Format an id into a buffer as a hex format string.
5199 *
5200 * If the buffer is smaller than {@link HEX_SIZE}+1, then the resulting
5201 * id string will be truncated to data.length-1 characters. If there are
5202 * any input parameter errors, then a pointer to an empty string is returned,
5203 * so that the return value can always be printed.
5204 *
5205 * @param buffer the buffer into which the id string is output.
5206 * @return the out buffer pointer, assuming no input parameter errors,
5207 * otherwise a pointer to an empty string.
5208 */
5209 [CCode(cname = "git_oid_tostr", instance_pos = -1)]
5210 public unowned string to_string_buffer([CCode(array_length_type = "size_t")] char[] buffer);
5211
5212 /**
5213 * Copy an id from one structure to another.
5214 *
5215 * @param dest id structure the result is written into.
5216 * @param src id structure to copy from.
5217 */
5218 [CCode(cname = "git_oid_cpy")]
5219 public static void copy(out object_id dest, object_id src);
5220
5221 /**
5222 * Copy an id from one structure to another.
5223 *
5224 * @param dest id structure the result is written into.
5225 */
5226 [CCode(cname = "git_oid_cpy", instance_pos = -1)]
5227 public void copy_to(out object_id dest);
5228
5229 /**
5230 * Compare two id structures.
5231 *
5232 * @param a first id structure.
5233 * @param b second id structure.
5234 * @return <0, 0, >0 if a < b, a == b, a > b.
5235 */
5236 [CCode(cname = "git_oid_cmp")]
5237 public static int compare(object_id a, object_id b);
5238
5239 /**
5240 * Compare two id structures.
5241 *
5242 * @param b second id structure.
5243 * @return <0, 0, >0 if a < b, a == b, a > b.
5244 */
5245 [CCode(cname = "git_oid_cmp")]
5246 public int compare_to(object_id b);
5247
5248 /**
5249 * Compare the first //len// hexadecimal characters (packets of 4 bits)
5250 * of two id structures.
5251 *
5252 * @param a first id structure.
5253 * @param b second id structure.
5254 * @param len the number of hex chars to compare
5255 * @return 0 in case of a match
5256 */
5257 [CCode(cname = "git_oid_ncmp")]
5258 public static int compare_n(object_id a, object_id b, size_t len);
5259
5260 /**
5261 * Compare the first //len// hexadecimal characters (packets of 4 bits)
5262 * of two id structures.
5263 *
5264 * @param b second id structure.
5265 * @param len the number of hex chars to compare
5266 * @return 0 in case of a match
5267 */
5268 [CCode(cname = "git_oid_ncmp")]
5269 public int compare_n_to(object_id b, size_t len);
5270
5271 /**
5272 * Check if an oid equals an hex formatted object id.
5273 *
5274 * @param str input hex string of an object id.
5275 * @return {@link Error.OK} in case of a match, {@link Error.ERROR} otherwise.
5276 */
5277 [CCode(cname = "git_oid_streq")]
5278 public Error compare_string(string str);
5279 /**
5280 * Compare two oid structures for equality
5281 *
5282 * @param a first id structure.
5283 * @param b second id structure.
5284 * @return true if equal, false otherwise
5285 */
5286 [CCode(cname = "git_oid_equal")]
5287 public static bool equal(object_id a, object_id b);
5288 /**
5289 * Compare two oid structures for equality
5290 *
5291 * @param b second id structure.
5292 * @return true if equal, false otherwise
5293 */
5294 [CCode(cname = "git_oid_equal")]
5295 public bool equal_to(object_id b);
5296
5297 /**
5298 * Determine the id of a buffer containing an object
5299 *
5300 * The resulting id will the itentifier for the data
5301 * buffer as if the data buffer it were to written to the ODB.
5302 *
5303 * @param id the resulting id.
5304 * @param data data to hash
5305 * @param type of the data to hash
5306 */
5307 [CCode(cname = "git_odb_hash")]
5308 public static Error from_data(out object_id id, [CCode(array_length_type = "size_t")] uint8[] data, ObjectType type);
5309
5310 /**
5311 * Read a file from disk and determine the id
5312 *
5313 * Read the file and compute the id have if it were
5314 * written to the database as an object of the given type.
5315 * Similar functionality to git's //git hash-object// without
5316 * the //-w// flag.
5317 *
5318 * @param id id structure the result is written into.
5319 * @param path file to read and determine object id for
5320 * @param type the type of the object that will be hashed
5321 */
5322 [CCode(cname = "git_odb_hashfile")]
5323 public static Error hashfile(out object_id id, string path, ObjectType type);
5324 /**
5325 * Check is an oid is all zeros.
5326 */
5327 [CCode(cname = "git_oid_iszero")]
5328 public bool is_zero();
5329
5330 }
5331 /**
5332 * Controls the behavior of a {@link Push} object.
5333 */
5334 [CCode(cname = "git_push_options", has_type_id = false, default_value = "GIT_PUSH_OPTIONS_INIT")]
5335 public struct push_options {
5336 [CCode(cname = "GIT_PUSH_OPTIONS_VERSION")]
5337 public const uint VERSION;
5338 public uint version;
5339 /**
5340 * If the transport being used to push to the remote requires the creation
5341 * of a pack file, this controls the number of worker threads used by the
5342 * packbuilder when creating that pack file to be sent to the remote.
5343 *
5344 * If set to false, the packbuilder will auto-detect the number of threads
5345 * to create. The default value is true.
5346 */
5347 public bool pb_parallelism;
5348 }
5349 [CCode(cname = "struct git_refdb_backend", default_value = "GIT_ODB_BACKEND_INIT", has_type_id = false)]
5350 public struct refdb_backend {
5351 [CCode(cname = "GIT_ODB_BACKEND_VERSION")]
5352 public const uint VERSION;
5353 public uint version;
5354 public RefDbCompress? compress;
5355 public RefDbDelete @delete;
5356 public RefDbExists exists;
5357 public RefDbForEach @foreach;
5358 public RefDbForEachGlob? foreach_glob;
5359 public RefDbFree? free;
5360 public RefDbLookup lookup;
5361 public RefDbWrite write;
5362 /**
5363 * Constructors for default refdb backend.
5364 */
5365 [CCode(cname = "git_refdb_backend_fs")]
5366 public static Error create_backend_fs(out refdb_backend? backend, Repository repo, RefDb refdb);
5367 }
5368 /**
5369 * Reference specification (i.e., some kind of local or remote branch)
5370 */
5371 [CCode(cname = "git_refspec", has_type_id = false, destroy_function = "")]
5372 public struct ref_spec {
5373 /**
5374 * The destination specifier
5375 */
5376 public string destination {
5377 [CCode(cname = "git_refspec_dst")]
5378 get;
5379 }
5380 /**
5381 * The force update setting
5382 */
5383 public bool is_forced {
5384 [CCode(cname = "git_refspec_force")]
5385 get;
5386 }
5387
5388 /**
5389 * The source specifier
5390 */
5391 public string source {
5392 [CCode(cname = "git_refspec_src")]
5393 get;
5394 }
5395
5396 /**
5397 * Check if a refspec's source descriptor matches a reference name
5398 *
5399 * @param refname the name of the reference to check
5400 */
5401 [CCode(cname = "git_refspec_src_matches")]
5402 public bool matches_source(string refname);
5403
5404 /**
5405 * Check if a refspec's destination descriptor matches a reference
5406 *
5407 * @param refname the name of the reference to check
5408 */
5409 [CCode(cname = "git_refspec_dst_matches")]
5410 public bool matches_destination(string refname);
5411
5412 /**
5413 * Transform a target reference to its source reference following the refspec's rules
5414 *
5415 * @param refname where to store the source reference name
5416 * @param name the name of the reference to transform
5417 */
5418 [CCode(cname = "git_refspec_rtransform", instance_pos = 1.2)]
5419 public Error rtransform([CCode(array_length_type = "size_t")] uint8[] refname, string name);
5420
5421 /**
5422 * Transform a reference to its target following the refspec's rules
5423 *
5424 * @param buffer where to store the target name
5425 * @param name the name of the reference to transform
5426 * @return {@link Error.OK}, {@link Error.SHORTBUFFER} or another error
5427 */
5428 [CCode(cname = "git_refspec_transform", instance_pos = 1.3)]
5429 public Error transform([CCode(array_length_type = "size_t")] char[] buffer, string name);
5430 }
5431
5432
5433 /**
5434 * Remote head description, given out on //ls// calls.
5435 */
5436 [CCode(cname = "struct git_remote_head", has_type_id = false)]
5437 public struct remote_head {
5438 public bool local;
5439 [CCode(cname = "oid")]
5440 public object_id id;
5441 [CCode(cname = "loid")]
5442 public object_id l_id;
5443 public unowned string name;
5444 }
5445
5446 [CCode(cname = "git_remote_callbacks", simple_generics = true, default_value = "GIT_REMOTE_CALLBACKS_INIT ")]
5447 public struct remote_callbacks<T> {
5448 [CCode(cname = "GIT_REMOTE_CALLBACKS_VERSION")]
5449 public const uint VERSION;
5450
5451 public uint version;
5452 public RemoteProgress<T>? progress;
5453 public RemoteCompletion<T>? completion;
5454 public RemoteUpdateTips<T>? update_tips;
5455
5456 [CCode(simple_generics = true)]
5457 public T payload;
5458 }
5459 /**
5460 * The smart transport knows how to speak the git protocol, but it has no
5461 * knowledge of how to establish a connection between it and another
5462 * endpoint, or how to move data back and forth.
5463 *
5464 * For this, a subtransport interface is declared, and the smart transport
5465 * delegates this work to the subtransports. Three subtransports are
5466 * implemented: git, http, and winhttp. (The http and winhttp transports each
5467 * implement both http and https.)
5468 *
5469 * Subtransports can either be persistent or stateless (request/response).
5470 * The smart transport handles the differences in its own logic.
5471 */
5472 [CCode(cname = "git_smart_subtransport")]
5473 public struct smart_subtransport {
5474 public SubTransportAction action;
5475
5476 /**
5477 * Subtransports are guaranteed a call to {@link close} between calls to
5478 * {@link action}, except for the following two natural progressions of
5479 * actions against a constant URL.
5480 *
5481 * 1. {@link SmartService.UPLOADPACK_LS} → {@link SmartService.UPLOADPACK}
5482 * 2. {@link SmartService.RECEIVEPACK_LS} → {@link SmartService.RECEIVEPACK}
5483 */
5484 public SubTransportClose close;
5485 public SubTransportFree free;
5486 }
5487 [CCode(cname = "git_smart_subtransport_definition")]
5488 public struct smart_subtransport_definition {
5489 /**
5490 * Create an instance of the smart transport.
5491 *
5492 * @param owner The {@link Remote} which will own this transport
5493 */
5494 [CCode(cname = "git_transport_smart", instance_pos = -1)]
5495 public Error create_transport(out transport? transport, Remote owner);
5496
5497 /**
5498 * The function to use to create the subtransport
5499 */
5500 public CreateSubTransport callback;
5501
5502 /**
5503 * Is the protocol is stateless.
5504 *
5505 * For example, http:// is stateless, but git:// is not.
5506 */
5507 [CCode(cname = "rpc")]
5508 public bool rpc;
5509 }
5510 /**
5511 * A stream used by the smart transport to read and write data from a
5512 * subtransport
5513 */
5514 [CCode(cname = "git_smart_subtransport_stream")]
5515 public struct smart_subtransport_stream {
5516 /**
5517 * The owning subtransport
5518 */
5519 public unowned smart_subtransport? subtransport;
5520 public SubTransportStreamRead read;
5521 public SubTransportStreamWrite write;
5522 public SubTransportStreamFree free;
5523 }
5524 [CCode(cname = "git_status_options", has_type_id = false, default_value = "GIT_STATUS_OPTIONS_INIT")]
5525 public struct status_options {
5526 [CCode(cname = "GIT_STATUS_OPTIONS_VERSION")]
5527 public const uint VERSION;
5528
5529 public uint version;
5530 StatusShow show;
5531 StatusControl flags;
5532 /**
5533 * The path patterns to match (using fnmatch-style matching), or just an
5534 * array of paths to match exactly if {@link DiffFlags.DISABLE_PATHSPEC_MATCH}
5535 * is specified in the flags.
5536 */
5537 string_array pathspec;
5538 }
5539
5540 /**
5541 * Collection of strings
5542 */
5543 [CCode(cname = "git_strarray", destroy_function = "git_strarray_free", has_type_id = false)]
5544 public struct string_array {
5545 [CCode(array_length_cname = "count", array_length_type = "size_t")]
5546 string[]? strings;
5547 [CCode(cname = "git_strarray_copy", instance_pos = -1)]
5548 public Error copy(out string_array target);
5549 }
5550
5551 /**
5552 * Time in a signature
5553 */
5554 [CCode(cname = "git_time", has_type_id = false)]
5555 public struct time {
5556 /**
5557 * time in seconds from epoch
5558 */
5559 int64 time;
5560 /**
5561 * timezone offset, in minutes
5562 */
5563 int offset;
5564 }
5565 [CCode(cname = "git_transfer_progress", has_type_id = false)]
5566 public struct transfer_progress {
5567 public uint total_objects;
5568 public uint indexed_objects;
5569 public uint received_objects;
5570 public size_t received_bytes;
5571 }
5572 [CCode(cname = "git_transport", has_type_id = false, default_value = "GIT_TRANSPORT_INIT ")]
5573 public struct transport {
5574 [CCode(cname = "GIT_TRANSPORT_VERSION")]
5575 public const uint VERSION;
5576 public uint version;
5577 /**
5578 * Set progress and error callbacks
5579 */
5580 public TransportSetCallbacks set_callbacks;
5581 /**
5582 * Connect the transport to the remote repository, using the given
5583 * direction.
5584 */
5585 public TransportConnect connect;
5586 /**
5587 * This function may be called after a successful call to {@link connect}.
5588 *
5589 * The provided callback is invoked for each ref discovered on the remote
5590 * end.
5591 */
5592 public TransportList ls;
5593 /**
5594 * Executes the push whose context is in a {@link Push} object.
5595 */
5596 public TransportPush push;
5597 /**
5598 * The function performs a negotiation to calculate the wants list for the
5599 * fetch.
5600 *
5601 * This function may be called after a successful call to {@link connect},
5602 * when the direction is FETCH.
5603 */
5604 public TransportNegotiatFetch negotiate_fetch;
5605 /**
5606 * This function retrieves the pack file for the fetch from the remote end.
5607 *
5608 * This function may be called after a successful call to
5609 * {@link negotiate_fetch}, when the direction is FETCH.
5610 */
5611 public TransportDownloadPack download_pack;
5612 /**
5613 * Checks to see if the transport is connected
5614 */
5615 public TransportIsConnected is_connected;
5616 /**
5617 * Reads the flags value previously passed into {@link connect}
5618 */
5619 public TransportReadFlags read_flags;
5620 /**
5621 * Cancels any outstanding transport operation
5622 */
5623 public TransportCancel cancel;
5624 /**
5625 * This function is the reverse of {@link connect} – it terminates the
5626 * connection to the remote end.
5627 */
5628 public TransportClose close;
5629 /**
5630 * Frees/destructs the transport object.
5631 */
5632 public TransportFree free;
5633
5634 /**
5635 * Function to use to create a transport from a URL.
5636 *
5637 * The transport database is scanned to find a transport that implements
5638 * the scheme of the URI (e.g., git:// or http://) and a transport object
5639 * is returned to the caller.
5640 *
5641 * @param owner The {@link Remote} which will own this transport
5642 * @param url The URL to connect to
5643 */
5644 [CCode(cname = "git_transport_new")]
5645 public static Error create(out transport? transport, Remote owner, string url);
5646
5647 /**
5648 * Create an instance of the dummy transport.
5649 *
5650 * @param owner The {@link Remote} which will own this transport
5651 * @param payload You must pass null for this parameter.
5652 */
5653 [CCode(cname = "git_transport_dummy")]
5654 public static Error create_dummy(out transport? transport, Remote owner, void* payload = null);
5655 /**
5656 * Create an instance of the local transport.
5657 *
5658 * @param owner The {@link Remote} which will own this transport
5659 * @param payload You must pass null for this parameter.
5660 */
5661 [CCode(cname = "git_transport_local")]
5662 public static Error create_local(out transport? transport, Remote owner, void* payload = null);
5663
5664 /**
5665 * Create an instance of the http subtransport.
5666 *
5667 * This subtransport also supports https. On Win32, this subtransport may
5668 * be implemented using the WinHTTP library.
5669 */
5670 [CCode(cname = "git_smart_subtransport_http", instance_pos = -1)]
5671 public Error create_http_subtransport(out smart_subtransport? subtransport);
5672
5673 /**
5674 * Create an instance of the git subtransport.
5675 */
5676 [CCode(cname = "git_smart_subtransport_git", instance_pos = -1)]
5677 public Error create_git_subtransport(out smart_subtransport? subtransport);
5678 }
5679
5680 /**
5681 * Default port for git: protocol.
5682 */
5683 [CCode(cname = "GIT_DEFAULT_PORT")]
5684 public const string DEFAULT_PORT;
5685
5686 /**
5687 * The separator used in path list strings.
5688 *
5689 * For instance, in the //$PATH// environment variable). A semi-colon ";"
5690 * is used on Windows, and a colon ":" for all other systems.
5691 */
5692 [CCode(cname = "GIT_PATH_LIST_SEPARATOR")]
5693 public const char PATH_LIST_SEPARATOR;
5694
5695 /**
5696 * The maximum length of a git valid git path.
5697 */
5698 [CCode(cname = "GIT_PATH_MAX")]
5699 public const int PATH_MAX;
5700
5701 [CCode(cname = "uint32_t", cprefix = "GIT_ATTR_CHECK_", has_type_id = false)]
5702 [Flags]
5703 public enum AttrCheck {
5704 /**
5705 * Reading values from index and working directory.
5706 *
5707 * When checking attributes, it is possible to check attribute files
5708 * in both the working directory (if there is one) and the index (if
5709 * there is one). You can explicitly choose where to check and in
5710 * which order using the following flags.
5711 *
5712 * Core git usually checks the working directory then the index,
5713 * except during a checkout when it checks the index first. It will
5714 * use index only for creating archives or for a bare repo (if an
5715 * index has been specified for the bare repo).
5716 */
5717 FILE_THEN_INDEX,
5718 /**
5719 * @see FILE_THEN_INDEX
5720 */
5721 INDEX_THEN_FILE,
5722 /**
5723 * @see FILE_THEN_INDEX
5724 */
5725 INDEX_ONLY,
5726 /**
5727 * Using the system attributes file.
5728 *
5729 * Normally, attribute checks include looking in the /etc (or system
5730 * equivalent) directory for a `gitattributes` file. Passing this
5731 * flag will cause attribute checks to ignore that file.
5732 */
5733 NO_SYSTEM
5734 }
5735
5736 /**
5737 * States for a file in the index
5738 */
5739 [CCode(cname = "int", cprefix = "GIT_IDXENTRY_", has_type_id = false)]
5740 [Flags]
5741 public enum Attributes {
5742 EXTENDED,
5743 VALID,
5744 UPDATE,
5745 REMOVE,
5746 UPTODATE,
5747 ADDED,
5748 HASHED,
5749 UNHASHED,
5750 WT_REMOVE,
5751 CONFLICTED,
5752 UNPACKED,
5753 NEW_SKIP_WORKTREE,
5754 INTENT_TO_ADD,
5755 SKIP_WORKTREE,
5756 EXTENDED2,
5757 EXTENDED_FLAGS
5758 }
5759 [CCode(cname = "git_remote_autotag_option_t", cprefix = "GIT_REMOTE_DOWNLOAD_TAGS_", has_type_id = false)]
5760 public enum AutoTag {
5761 UNSET,
5762 NONE,
5763 AUTO,
5764 ALL
5765 }
5766
5767 /**
5768 * Basic type of any Git branch.
5769 */
5770 [CCode(cname = "git_branch_t", cprefix = "GIT_BRANCH_", has_type_id = false)]
5771 [Flags]
5772 public enum BranchType {
5773 LOCAL,
5774 REMOTE
5775 }
5776 /**
5777 * Combinations of these values describe the capabilities of libgit2.
5778 */
5779 [CCode(cname = "int", cprefix = "GIT_CAP_", has_type_id = false)]
5780 public enum Capabilities {
5781 /**
5782 * Libgit2 was compiled with thread support.
5783 *
5784 * Note that thread support is still to be seen as a 'work in progress'.
5785 */
5786 THREADS,
5787 /**
5788 * Libgit2 supports the https protocol.
5789 *
5790 * This requires the OpenSSL library to be found when compiling libgit2.
5791 */
5792 HTTPS;
5793 /**
5794 * Query compile time options for libgit2.
5795 */
5796 [CCode(cname = "git_libgit2_capabilities")]
5797 public static Capabilities get();
5798 }
5799 /**
5800 * Options for which cases to invoke notification callback.
5801 */
5802 [CCode(cname = "git_checkout_notify_t", has_type_id = false, cprefix = "GIT_CHECKOUT_NOTIFY_")]
5803 [Flags]
5804 public enum CheckoutNotify {
5805 NONE,
5806 /**
5807 * Invokes callback on conflicting paths.
5808 */
5809 CONFLICT,
5810 /**
5811 * Invokes callback to notify about "dirty" files, i.e. those that do not
5812 * need an update but no longer match the baseline. Core git displays
5813 * these files when checkout runs, but won't stop the checkout.
5814 */
5815 DIRTY,
5816 /**
5817 * Invokes callback to notify for any changed file.
5818 */
5819 UPDATED,
5820 /**
5821 * Invokes callback to notify about untracked files.
5822 */
5823 UNTRACKED,
5824 /**
5825 * Invokes callback to notify about ignored files.
5826 */
5827 IGNORED
5828 }
5829
5830 /**
5831 * Control what checkout does with files
5832 *
5833 * No flags does a "dry run" where no files will be modified.
5834 *
5835 * Checkout groups the working directory content into 3 classes of files: (1)
5836 * files that don't need a change, and files that do need a change that
5837 * either (2) we are allowed to modifed or (3) we are not. The flags you
5838 * pass in will decide which files we are allowed to modify.
5839 *
5840 * By default, checkout is not allowed to modify any files. Anything needing
5841 * a change would be considered a conflict.
5842 *
5843 * If any files need update but are disallowed by the strategy, normally
5844 * checkout calls the conflict callback (if given) and then aborts.
5845 *
5846 * Any unmerged entries in the index are automatically considered conflicts.
5847 */
5848 [CCode(cname = "git_checkout_strategy_t", has_type_id = false, cprefix = "GIT_CHECKOUT_")]
5849 [Flags]
5850 public enum CheckoutStategy {
5851 /**
5852 * Dry run, no actual updates
5853 */
5854 NONE,
5855 /**
5856 * Allow safe updates that cannot overwrite uncommited data
5857 */
5858 SAFE,
5859 /**
5860 * Allow safe updates plus creation of missing files
5861 */
5862 SAFE_CREATE,
5863 /**
5864 * Allow all updates to force working directory to look like index
5865 */
5866 FORCE,
5867 /**
5868 * Allow checkout to make safe updates even if conflicts are found
5869 *
5870 * It is okay to update the files that are allowed by the strategy even if
5871 * there are conflicts. The conflict callbacks are still made, but
5872 * non-conflicting files will be updated.
5873 */
5874 ALLOW_CONFLICTS,
5875 /**
5876 * Remove untracked files not in index (that are not ignored)
5877 */
5878 REMOVE_UNTRACKED,
5879 /**
5880 * Remove ignored files not in index
5881 */
5882 REMOVE_IGNORED,
5883 /**
5884 * Only update existing files, don't create new ones
5885 */
5886 UPDATE_ONLY,
5887 /**
5888 * Normally checkout updates index entries as it goes; this stops that
5889 */
5890 DONT_UPDATE_INDEX,
5891 /**
5892 * Don't refresh index/config/etc before doing checkout
5893 */
5894 NO_REFRESH,
5895 /**
5896 * Treat pathspec as simple list of exact match file paths
5897 */
5898 DISABLE_PATHSPEC_MATCH,
5899 /**
5900 * Allow checkout to skip unmerged files (NOT IMPLEMENTED)
5901 */
5902 SKIP_UNMERGED,
5903 USE_OURS,
5904 /**
5905 * For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED)
5906 */
5907 USE_THEIRS,
5908 /**
5909 * Recursively checkout submodules with same options (NOT IMPLEMENTED)
5910 */
5911 UPDATE_SUBMODULES,
5912 /**
5913 * Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
5914 */
5915 UPDATE_SUBMODULES_IF_CHANGED
5916 }
5917
5918 /**
5919 * Priority level of a config file.
5920 *
5921 * These priority levels correspond to the natural escalation logic (from
5922 * higher to lower) when searching for config entries in git.git.
5923 */
5924 [CCode(cname = "int", cprefix = "GIT_CONFIG_LEVEL_", has_type_id = false)]
5925 public enum ConfigLevel {
5926 /**
5927 * System-wide configuration file.
5928 */
5929 SYSTEM,
5930 /**
5931 * XDG compatible configuration file: '''.config/git/config'''
5932 */
5933 XDG,
5934 /**
5935 * User-specific configuration file, also called global configuration file.
5936 */
5937 GLOBAL,
5938 /**
5939 * Repository specific configuration file.
5940 */
5941 LOCAL,
5942 /**
5943 * Represents the highest level of a config file.
5944 */
5945 LEVEL,
5946 }
5947
5948 [CCode(cname = "git_cvar_t", cprefix = "GIT_CVAR_", has_type_id = false)]
5949 public enum ConfigVar {
5950 FALSE,
5951 TRUE,
5952 INT32,
5953 STRING
5954 }
5955
5956 [CCode(cname = "git_credtype_t", cprefix = "GIT_CREDTYPE_", has_type_id = false)]
5957 [Flags]
5958 public enum CredTypes {
5959 USERPASS_PLAINTEXT
5960 }
5961
5962 /**
5963 * What type of change is described?
5964 */
5965 [CCode(cname = "git_delta_t", cprefix = "GIT_DELTA_", has_type_id = false)]
5966 public enum DeltaType {
5967 /**
5968 * Use in queries to include all delta types.
5969 */
5970 [CCode(cname = "(-1)")]
5971 ALL,
5972 /**
5973 * No changes
5974 */
5975 UNMODIFIED,
5976 /**
5977 * Entry does not exist in old version
5978 */
5979 ADDED,
5980 /**
5981 * Entry does not exist in new version
5982 */
5983 DELETED,
5984 /**
5985 * Entry content changed between old and new
5986 */
5987 MODIFIED,
5988 /**
5989 * Entry was renamed between old and new
5990 */
5991 RENAMED,
5992 /**
5993 * Entry was copied from another old entry
5994 */
5995 COPIED,
5996 /**
5997 * Entry is ignored item in workdir
5998 */
5999 IGNORED,
6000 /**
6001 * Entry is untracked item in workdir
6002 */
6003 UNTRACKED,
6004 /**
6005 * Type of entry changed between old and new
6006 */
6007 TYPECHANGE;
6008 /**
6009 * Look up the single character abbreviation for a delta status code.
6010 *
6011 * When you call {@link DiffList.print_compact} it prints single letter
6012 * codes into the output such as 'A' for added, 'D' for deleted, 'M' for
6013 * modified, etc. It is sometimes convenient to convert a {@link DeltaType}
6014 * value into these letters for your own purposes. This function does just
6015 * that. By the way, unmodified will return a space (i.e. ' ').
6016 */
6017 [CCode(cname = "git_diff_status_char")]
6018 public char to_char();
6019 }
6020 /**
6021 * Flags that can be set for the file on side of a diff.
6022 */
6023 [CCode(cname = "uint32", cprefix = "GIT_DIFF_FLAG_", has_type_id = false)]
6024 [Flags]
6025 public enum DiffFlag {
6026 /**
6027 * File(s) treated as binary data
6028 */
6029 BINARY,
6030 /**
6031 * File(s) treated as text data
6032 */
6033 NOT_BINARY,
6034 /**
6035 * Id value is known correct
6036 */
6037 [CCode(cname = "GIT_DIFF_FLAG_VALID_OID")]
6038 VALID_OID
6039 }
6040 /**
6041 * Control the behavior of diff rename/copy detection.
6042 */
6043 [CCode(cname = "unsigned int", cprefix = "GIT_DIFF_FIND_", has_type_id = false)]
6044 [Flags]
6045 public enum DiffFind {
6046 /**
6047 * Look for renames?
6048 */
6049 RENAMES,
6050 /**
6051 * Consider old side of modified for renames?
6052 */
6053 RENAMES_FROM_REWRITES,
6054 /**
6055 * Look for copies?
6056 */
6057 COPIES,
6058 /**
6059 * Consider unmodified as copy sources?
6060 */
6061 COPIES_FROM_UNMODIFIED,
6062 /**
6063 * Split large rewrites into delete/add pairs.
6064 */
6065 AND_BREAK_REWRITES,
6066 /**
6067 * Turn on all finding features
6068 */
6069 ALL,
6070 /**
6071 * Measure similarity ignoring leading whitespace (default)
6072 */
6073 IGNORE_LEADING_WHITESPACE,
6074 /**
6075 * Measure similarity ignoring all whitespace
6076 */
6077 IGNORE_WHITESPACE,
6078 /**
6079 * Measure similarity including all data
6080 */
6081 DONT_IGNORE_WHITESPACE
6082 }
6083
6084 [CCode(cname = "uint32_t", cprefix = "GIT_DIFF_", has_type_id = false)]
6085 [Flags]
6086 public enum DiffFlags {
6087 /**
6088 * Normal diff, the default
6089 */
6090 NORMAL,
6091 /**
6092 * Reverse the sides of the diff
6093 */
6094 REVERSE,
6095 /**
6096 * Treat all files as text, disabling binary attributes & detection
6097 */
6098 FORCE_TEXT,
6099 /**
6100 * Ignore all whitespace
6101 */
6102 IGNORE_WHITESPACE,
6103 /**
6104 * Ignore changes in amount of whitespace
6105 */
6106 IGNORE_WHITESPACE_CHANGE,
6107 /**
6108 * Ignore whitespace at end of line
6109 */
6110 IGNORE_WHITESPACE_EOL,
6111 /**
6112 * Exclude submodules from the diff completely
6113 */
6114 IGNORE_SUBMODULES,
6115 /**
6116 * Use the "patience diff" algorithm (currently unimplemented)
6117 */
6118 PATIENCE,
6119 /**
6120 * Include ignored files in the diff list
6121 */
6122 INCLUDE_IGNORED,
6123 /**
6124 * Include untracked files in the diff list
6125 */
6126 INCLUDE_UNTRACKED,
6127 /**
6128 * Include unmodified files in the diff list
6129 */
6130 INCLUDE_UNMODIFIED,
6131 /**
6132 * Even with the {@link INCLUDE_UNTRACKED} flag, when an untracked
6133 * directory is found, only a single entry for the directory is added to
6134 * the diff list; with this flag, all files under the directory will be
6135 * included, too.
6136 */
6137 RECURSE_UNTRACKED_DIRS,
6138 /**
6139 * If the pathspec is set in the diff options, this flags means to apply it
6140 * as an exact match instead of as an fnmatch pattern.
6141 */
6142 DISABLE_PATHSPEC_MATCH,
6143 /**
6144 * Use case insensitive filename comparisons
6145 */
6146 DELTAS_ARE_ICASE,
6147 /**
6148 * When generating patch text, include the content of untracked files
6149 */
6150 INCLUDE_UNTRACKED_CONTENT,
6151 /**
6152 * Disable updating of the binary flag in delta records. This is useful
6153 * when iterating over a diff if you don't need hunk and data callbacks and
6154 * want to avoid having to load file completely.
6155 */
6156 SKIP_BINARY_CHECK,
6157 /**
6158 * Normally, a type change between files will be converted into a DELETED
6159 * record for the old and an ADDED record for the new; this options enabled
6160 * the generation of TYPECHANGE delta records.
6161 */
6162 INCLUDE_TYPECHANGE,
6163 /**
6164 * Even with {@link INCLUDE_TYPECHANGE}, blob to tree changes still
6165 * generally show as a DELETED blob. This flag tries to correctly label
6166 * blob to tree transitions as TYPECHANGE records with the new file's mode
6167 * set to tree.
6168 *
6169 * Note: the tree SHA will not be available.
6170 */
6171 INCLUDE_TYPECHANGE_TREES,
6172 /**
6173 * Ignore file mode changes
6174 */
6175 IGNORE_FILEMODE,
6176 /**
6177 * Even with {@link INCLUDE_IGNORED}, an entire ignored directory will be
6178 * marked with only a single entry in the diff list; this flag adds all
6179 * files under the directory as IGNORED entries, too.
6180 */
6181 RECURSE_IGNORED_DIRS
6182 }
6183
6184 /**
6185 * Line origin constants.
6186 *
6187 * These values describe where a line came from and will be passed to
6188 * the {@link DiffLine} when iterating over a diff. There are some
6189 * special origin contants at the end that are used for the text
6190 * output callbacks to demarcate lines that are actually part of
6191 * the file or hunk headers.
6192 */
6193 [CCode(cname = "char", cprefix = "GIT_DIFF_LINE_", has_type_id = false)]
6194 public enum DiffLineType {
6195 CONTEXT,
6196 ADDITION,
6197 DELETION,
6198 [Deprecated]
6199 ADD_EOFNL,
6200 DEL_EOFNL,
6201 FILE_HDR,
6202 HUNK_HDR,
6203 BINARY;
6204 [CCode(cname = "")]
6205 public char to_char();
6206 }
6207
6208 /**
6209 * Transfer direction in a transport
6210 */
6211 [CCode(cname = "int", cprefix = "GIT_DIR_", has_type_id = false)]
6212 public enum Direction {
6213 FETCH, PUSH
6214 }
6215
6216 /**
6217 * Return codes for many functions.
6218 */
6219 [CCode(cname = "git_error_t", cprefix = "GIT_E", has_type_id = false)]
6220 public enum Error {
6221 [CCode(cname = "GIT_OK")]
6222 OK,
6223 [CCode(cname = "GIT_ERROR")]
6224 ERROR,
6225 /**
6226 * Input does not exist in the scope searched
6227 */
6228 NOTFOUND,
6229 /**
6230 * A reference with this name already exists
6231 */
6232 EXISTS,
6233 /**
6234 * The given integer literal is too large to be parsed
6235 */
6236 OVERFLOW,
6237 /**
6238 * The given short {@link object_id} is ambiguous
6239 */
6240 AMBIGUOUS,
6241 BUFS,
6242 USER,
6243 /**
6244 * Skip and passthrough the given ODB backend
6245 */
6246 PASSTHROUGH,
6247 /**
6248 * The buffer is too short to satisfy the request
6249 */
6250 SHORTBUFFER,
6251 /**
6252 * The revsion walk is complete.
6253 */
6254 ITEROVER,
6255 SSL,
6256 BAREREPO,
6257 ORPHANEDHEAD,
6258 UNMERGED,
6259 NONFASTFORWARD,
6260 INVALIDSPEC,
6261 MERGECONFLICT
6262 }
6263
6264 [CCode(cname = "git_error_class", cprefix = "GITERR_", has_type_id = false)]
6265 public enum ErrClass {
6266 NOMEMORY,
6267 OS,
6268 INVALID,
6269 REFERENCE,
6270 ZLIB,
6271 REPOSITORY,
6272 CONFIG,
6273 REGEX,
6274 ODB,
6275 INDEX,
6276 OBJECT,
6277 NET,
6278 TAG,
6279 TREE,
6280 INDEXER,
6281 SSL,
6282 SUBMODULE,
6283 THREAD,
6284 STASH,
6285 CHECKOUT,
6286 FETCHHEAD,
6287 MERGE;
6288 /**
6289 * Set the error message string for this thread.
6290 *
6291 * This function is public so that custom ODB backends and the like can
6292 * relay an error message through libgit2. Most regular users of libgit2
6293 * will never need to call this function -- actually, calling it in most
6294 * circumstances (for example, calling from within a callback function)
6295 * will just end up having the value overwritten by libgit2 internals.
6296 *
6297 * This error message is stored in thread-local storage and only applies to
6298 * the particular thread that this libgit2 call is made from.
6299 *
6300 * {@link ErrClass.OS} has a special behavior: we attempt to append the
6301 * system default error message for the last OS error that occurred and
6302 * then clear the last error. The specific implementation of looking up
6303 * and clearing this last OS error will vary by platform.
6304 *
6305 * @param message The formatted error message to keep
6306 */
6307 [CCode(cname = "giterr_set_str")]
6308 void raise(string message);
6309 }
6310 /**
6311 * The UNIX file mode associated with a {@link TreeEntry}.
6312 *
6313 * Consult the mode_t manual page.
6314 */
6315 [CCode(cname = "unsigned int", cheader_filename = "sys/stat.h", cprefix = "S_I", has_type_id = false)]
6316 [Flags]
6317 public enum FileMode {
6318 /**
6319 * This is the mask to isolate only the F modes.
6320 */
6321 FMT,
6322 /**
6323 * A block device
6324 */
6325 FBLK,
6326 /**
6327 * A character device
6328 */
6329 FCHR,
6330 /**
6331 * A directory
6332 */
6333 FDIR,
6334 /**
6335 * A FIFO special
6336 */
6337 FIFO,
6338 /**
6339 * A symbolic link
6340 */
6341 FLNK,
6342 /**
6343 * A regular file
6344 */
6345 FREG,
6346 /**
6347 * A socket
6348 */
6349 FSOCK,
6350 /**
6351 * Read, write, and execute by owner
6352 */
6353 RWXU,
6354 /**
6355 * Read by owner
6356 */
6357 RUSR,
6358 /**
6359 * Write by owner
6360 */
6361 WUSR,
6362 /**
6363 * Execute by owner
6364 */
6365 XUSR,
6366 /**
6367 * Read, write, and execute by group
6368 */
6369 RWXG,
6370 /**
6371 * Read by group
6372 */
6373 RGRP,
6374 /**
6375 * Write by group
6376 */
6377 WGRP,
6378 /**
6379 * Execute by group
6380 */
6381 XGRP,
6382 /**
6383 * Read, write, and execute by others
6384 */
6385 RWXO,
6386 /**
6387 * Read by others
6388 */
6389 ROTH,
6390 /**
6391 * Write by others
6392 */
6393 WOTH,
6394 /**
6395 * Execute by others
6396 */
6397 XOTH,
6398 /**
6399 * Set user-id on execution
6400 */
6401 SUID,
6402 /**
6403 * Set group-id on execution
6404 */
6405 SGID,
6406 /**
6407 * Restricted delition on directories
6408 */
6409 SVTX;
6410 [CCode(cname = "S_ISBLK")]
6411 public bool is_block_dev();
6412 [CCode(cname = "S_ISCHR")]
6413 public bool is_char_dev();
6414 [CCode(cname = "S_ISDIR")]
6415 public bool is_dir();
6416 [CCode(cname = "S_ISFIFO")]
6417 public bool is_fifo();
6418 [CCode(cname = "S_ISREG")]
6419 public bool is_regular();
6420 [CCode(cname = "S_ISLNK")]
6421 public bool is_link();
6422 [CCode(cname = "S_ISSOCK")]
6423 public bool is_sock();
6424 /**
6425 * Converts the format mode to an ls-style long mode.
6426 */
6427 public string to_string() {
6428 char attr[11];
6429 switch (this&FileMode.FMT) {
6430 case FileMode.FBLK :
6431 attr[0] = 'b';
6432 break;
6433 case FileMode.FCHR :
6434 attr[0] = 'c';
6435 break;
6436 case FileMode.FDIR :
6437 attr[0] = 'd';
6438 break;
6439 case FileMode.FIFO :
6440 attr[0] = 'p';
6441 break;
6442 case FileMode.FLNK :
6443 attr[0] = 'l';
6444 break;
6445 case FileMode.FREG :
6446 attr[0] = '-';
6447 break;
6448 case FileMode.FSOCK :
6449 attr[0] = 's';
6450 break;
6451 default :
6452 attr[0] = '?';
6453 break;
6454 }
6455 attr[1] = check_mode(FileMode.RUSR, 'r');
6456 attr[2] = check_mode(FileMode.WUSR, 'w');
6457 attr[3] = check_mode_x(FileMode.RUSR, FileMode.SUID, 's');
6458 attr[4] = check_mode(FileMode.RGRP, 'r');
6459 attr[5] = check_mode(FileMode.WGRP, 'w');
6460 attr[6] = check_mode_x(FileMode.RGRP, FileMode.SGID, 's');
6461 attr[7] = check_mode(FileMode.ROTH, 'r');
6462 attr[8] = check_mode(FileMode.WOTH, 'w');
6463 attr[9] = check_mode_x(FileMode.ROTH, FileMode.SVTX, 't');
6464 attr[10] = '\0';
6465 return ((string) attr).dup();
6466 }
6467 char check_mode(FileMode mode, char symbol) {
6468 return mode in this ? symbol : '-';
6469 }
6470 char check_mode_x(FileMode mode, FileMode modifier, char symbol) {
6471 if ((mode|modifier) in this) {
6472 return symbol.tolower();
6473 }
6474 if (modifier in this) {
6475 return symbol.toupper();
6476 }
6477 return mode in this ? 'x' : '-';
6478 }
6479 }
6480 /**
6481 * Capabilities of system that affect index actions.
6482 */
6483 [Flags]
6484 [CCode(cname = "unsigned int", cprefix = "GIT_INDEXCAP_", has_type_id = false)]
6485 public enum IndexCapability {
6486 IGNORE_CASE,
6487 NO_FILEMODE,
6488 NO_SYMLINKS,
6489 /**
6490 * Read capabilites from the config of the owner object, looking at
6491 * '''core.ignorecase''', '''core.filemode''', '''core.symlinks'''.
6492 */
6493 FROM_OWNER
6494 }
6495 /**
6496 * Extra behaviors to {@link Repository.init_ext}.
6497 *
6498 * In every case, the default behavior is the flag not set.
6499 *
6500 */
6501 [CCode(cname = "uint32_t", cprefix = "GIT_REPOSITORY_INIT_", has_type_id = false)]
6502 [Flags]
6503 public enum InitFlag {
6504 /**
6505 * Create a bare repository with no working directory.
6506 */
6507 BARE,
6508 /**
6509 * Return an {@link Error.EXISTS} error if the path appears to already be
6510 * an git repository.
6511 */
6512 NO_REINIT,
6513 /**
6514 * Normally a '''/.git/''' will be appended to the repo path for non-bare
6515 * repos (if it is not already there), but passing this flag prevents that
6516 * behavior.
6517 */
6518 NO_DOTGIT_DIR,
6519 /**
6520 * Make the path (and working directory) as needed.
6521 *
6522 * Init is always willing to create the '''.git''' directory even without
6523 * this flag. This flag tells init to create the trailing component of the
6524 * repo and workdir paths as needed.
6525 */
6526 MKDIR,
6527 /**
6528 * Recursively make all components of the repo and workdir paths as
6529 * necessary.
6530 */
6531 MKPATH,
6532 /**
6533 * libgit2 normally uses internal templates to initialize a new repo. This
6534 * flags enables external templates, looking the '''template_path''' from
6535 * the options if set, or the '''init.templatedir''' global config if not,
6536 * or falling back on '''/usr/share/git-core/templates''' if it exists.
6537 */
6538 EXTERNAL_TEMPLATE
6539 }
6540 /**
6541 * Basic type (loose or packed) of any git object
6542 */
6543 [CCode(cname = "git_otype", cprefix = "GIT_OBJ_", has_type_id = false)]
6544 public enum ObjectType {
6545 /**
6546 * Object can be any of the following
6547 */
6548 ANY,
6549 /**
6550 * Object is invalid
6551 */
6552 BAD,
6553 /**
6554 * Reserved for future use
6555 */
6556 _EXT1,
6557 /**
6558 * A commit object
6559 */
6560 COMMIT,
6561 /**
6562 * A tree (directory listing) object
6563 */
6564 TREE,
6565 /**
6566 * A file revision object
6567 */
6568 BLOB,
6569 /**
6570 * An annotated tag object
6571 */
6572 TAG,
6573 /**
6574 * Reserved for future use
6575 */
6576 _EXT2,
6577 /**
6578 * A delta, base is given by an offset
6579 */
6580 OFS_DELTA,
6581 /**
6582 * A delta, base is given by {@link object_id}
6583 */
6584 REF_DELTA;
6585 /**
6586 * Convert an object type to its string representation
6587 */
6588 [CCode(cname = "git_object_type2string")]
6589 public unowned string to_string();
6590
6591 /**
6592 * Parse a string containing an object type
6593 *
6594 * @param str the string to convert
6595 * @return the corresponding object type
6596 */
6597 [CCode(cname = "git_object_string2type")]
6598 public static ObjectType from_string(string str);
6599
6600 /**
6601 * Determine if the given this type is a valid loose object type
6602 *
6603 * @return true if the type represents a valid loose object type, false otherwise.
6604 */
6605 [CCode(cname = "git_object_typeisloose")]
6606 public bool is_loose();
6607
6608 /**
6609 * Get the size in bytes for the structure which holding this object type
6610 */
6611 [CCode(cname = "git_object__size")]
6612 public size_t get_size();
6613 }
6614
6615 [CCode(cname = "unsigned int", cprefix = "GIT_REPOSITORY_OPEN_", has_type_id = false)]
6616 [Flags]
6617 public enum OpenFlags {
6618 NO_SEARCH,
6619 CROSS_FS
6620 }
6621 [CCode(cname = "unsigned int", cprefix = "GIT_REF_FORMAT_", has_type_id = false)]
6622 [Flags]
6623 public enum ReferenceFormat {
6624 NORMAL,
6625 /**
6626 * Control whether one-level refnames are accepted
6627 *
6628 * (i.e., refnames that do not contain multiple /-separated components)
6629 */
6630 ALLOW_ONELEVEL,
6631 /**
6632 * Interpret the provided name as a reference pattern for a refspec (as
6633 * used with remote repositories).
6634 *
6635 * If this option is enabled, the name is allowed to contain a single *
6636 * (<star>) in place of a one full pathname component (e.g., foo/<star>/bar
6637 * but not foo/bar<star>).
6638 */
6639 REFSPEC_PATTERN,
6640 }
6641 /**
6642 * Basic type of any Git reference.
6643 */
6644 [CCode(cname = "git_rtype", cprefix = "GIT_REF_", has_type_id = false)]
6645 [Flags]
6646 public enum ReferenceType {
6647 /**
6648 * Invalid reference
6649 */
6650 INVALID,
6651 /**
6652 * A reference which points at an object id
6653 */
6654 [CCode(cname = "GIT_REF_OID")]
6655 ID,
6656 /**
6657 * A reference which points at another reference
6658 */
6659 SYMBOLIC,
6660 LISTALL
6661 }
6662 /**
6663 * Which operation remote operation has finished.
6664 */
6665 [CCode(cname = "git_remote_completion_type", cprefix = "GIT_REMOTE_COMPLETION_", has_type_id = false)]
6666 public enum CompletionType {
6667 DOWNLOAD,
6668 INDEXING,
6669 ERROR
6670 }
6671
6672 /**
6673 * Kinds of reset operation.
6674 */
6675 [CCode(cname = "git_reset_type", cprefix = "GIT_RESET_", has_type_id = false)]
6676 public enum ResetType {
6677 SOFT,
6678 MIXED,
6679 HARD
6680 }
6681
6682 /**
6683 * Actions that the smart transport can ask a subtransport to perform
6684 */
6685 [CCode(cname = "git_smart_service_t", cprefix = "GIT_SERVICE_", has_type_id = false)]
6686 public enum SmartService {
6687 UPLOADPACK_LS,
6688 UPLOADPACK,
6689 RECEIVEPACK_LS,
6690 RECEIVEPACK
6691 }
6692
6693 /**
6694 * Sort order for revision walking.
6695 */
6696 [CCode(cname = "int", cprefix = "GIT_SORT_", has_type_id = false)]
6697 [Flags]
6698 public enum Sorting {
6699 /**
6700 * Sort the repository contents in no particular ordering;
6701 * this sorting is arbitrary, implementation-specific
6702 * and subject to change at any time.
6703 * This is the default sorting for new walkers.
6704 */
6705 NONE,
6706 /**
6707 * Sort the repository contents in topological order
6708 * (parents before children); this sorting mode
6709 * can be combined with time sorting.
6710 */
6711 TOPOLOGICAL,
6712 /**
6713 * Sort the repository contents by commit time;
6714 * this sorting mode can be combined with
6715 * topological sorting.
6716 */
6717 TIME,
6718 /**
6719 * Iterate through the repository contents in reverse
6720 * order; this sorting mode can be combined with
6721 * any of the above.
6722 */
6723 REVERSE
6724 }
6725 [CCode(cname = "unsigned int", cprefix = "GIT_STASH_", has_type_id = false)]
6726 [Flags]
6727 public enum StashFlag {
6728 DEFAULT,
6729 /**
6730 * All changes already added to the index are left intact in the working
6731 * directory
6732 */
6733 KEEP_INDEX,
6734 /**
6735 * All untracked files are also stashed and then cleaned up from the
6736 * working directory
6737 */
6738 INCLUDE_UNTRACKED,
6739 /**
6740 * All ignored files are also stashed and then cleaned up from the working
6741 * directory
6742 */
6743 INCLUDE_IGNORED
6744 }
6745
6746 [CCode(cname = "int", cprefix = "GIT_REPOSITORY_STATE_", has_type_id = false)]
6747 public enum State {
6748 NONE,
6749 MERGE,
6750 REVERT,
6751 CHERRY_PICK,
6752 BISECT,
6753 REBASE,
6754 REBASE_INTERACTIVE,
6755 REBASE_MERGE,
6756 APPLY_MAILBOX,
6757 APPLY_MAILBOX_OR_REBASE
6758 }
6759
6760 /**
6761 * Working directory file status
6762 */
6763 [CCode(cname = "int", cprefix = "GIT_STATUS_", has_type_id = false)]
6764 public enum Status {
6765 CURRENT,
6766 INDEX_NEW,
6767 INDEX_MODIFIED,
6768 INDEX_DELETED,
6769 WT_NEW,
6770 WT_MODIFIED,
6771 WT_DELETED,
6772 IGNORED
6773 }
6774 /**
6775 * Select the files on which to report status.
6776 */
6777 [CCode(cname = "git_status_show_t", has_type_id = false, cprefix = "GIT_STATUS_SHOW_")]
6778 public enum StatusShow {
6779 /**
6780 * The rough equivalent of '''git status --porcelain''' where each file
6781 * will receive a callback indicating its status in the index and in the
6782 * workdir.
6783 */
6784 INDEX_AND_WORKDIR,
6785 /**
6786 * Only make callbacks for index side of status.
6787 *
6788 * The status of the index contents relative to the HEAD will be given.
6789 */
6790 INDEX_ONLY,
6791 /**
6792 * Only make callbacks for the workdir side of status, reporting the status
6793 * of workdir content relative to the index.
6794 */
6795 WORKDIR_ONLY,
6796 /**
6797 * Behave like index-only followed by workdir-only, causing two callbacks
6798 * to be issued per file (first index then workdir).
6799 *
6800 * This is slightly more efficient than making separate calls. This makes
6801 * it easier to emulate the output of a plain '''git status'''.
6802 */
6803 INDEX_THEN_WORKDIR
6804 }
6805
6806 /**
6807 * Flags to control status callbacks
6808 */
6809 [CCode(cname = "unsigned int", cprefix = "GIT_STATUS_OPT_", has_type_id = false)]
6810 public enum StatusControl {
6811 /**
6812 * Callbacks should be made on untracked files.
6813 *
6814 * These will only be made if the workdir files are included in the status
6815 * "show" option.
6816 */
6817 INCLUDE_UNTRACKED,
6818 /**
6819 * Ignored files should get callbacks.
6820 *
6821 * These callbacks will only be made if the workdir files are included in
6822 * the status "show" option. Right now, there is no option to include all
6823 * files in directories that are ignored completely.
6824 */
6825 INCLUDE_IGNORED,
6826 /**
6827 * Callbacks should be made even on unmodified files.
6828 */
6829 INCLUDE_UNMODIFIED,
6830 /**
6831 * Directories which appear to be submodules should just be skipped over.
6832 */
6833 EXCLUDE_SUBMODULES,
6834 /**
6835 * The contents of untracked directories should be included in the status.
6836 *
6837 * Normally if an entire directory is new, then just the top-level
6838 * directory will be included (with a trailing slash on the entry name).
6839 * Given this flag, the directory itself will not be included, but all the
6840 * files in it will.
6841 */
6842 RECURSE_UNTRACKED_DIRS,
6843 DEFAULTS
6844 }
6845
6846 [CCode(cname = "git_submodule_update_t", cprefix = "GIT_SUBMODULE_UPDATE_", has_type_id = false)]
6847 public enum SubmoduleUpdate {
6848 DEFAULT,
6849 CHECKOUT,
6850 REBASE,
6851 MERGE,
6852 NONE
6853 }
6854
6855 [CCode(cname = "git_submodule_ignore_t", cpreifx = "GIT_SUBMODULE_IGNORE_", has_type_id = false)]
6856 public enum SubmoduleIgnore {
6857 /**
6858 * The working directory will be consider clean so long as there is a
6859 * checked out version present.
6860 */
6861 ALL,
6862 /**
6863 * Only check if the HEAD of the submodule has moved for status.
6864 *
6865 * This is fast since it does not need to scan the working tree of the
6866 * submodule at all.
6867 */
6868 DIRTY,
6869 /**
6870 * Examines the contents of the working tree but untracked files will not
6871 * count as making the submodule dirty.
6872 */
6873 UNTRACKED,
6874 /**
6875 * Consider any change to the contents of the submodule from a clean
6876 * checkout to be dirty, including the addition of untracked files.
6877 *
6878 * This is the default if unspecified.
6879 */
6880 NONE
6881 }
6882
6883 /**
6884 * Submodule status
6885 *
6886 * Submodule info is contained in 4 places: the HEAD tree, the index, config
6887 * files (both .git/config and .gitmodules), and the working directory. Any
6888 * or all of those places might be missing information about the submodule
6889 * depending on what state the repo is in. We consider all four places to
6890 * build the combination of status flags.
6891 *
6892 * There are four values that are not really status, but give basic info
6893 * about what sources of submodule data are available. These will be
6894 * returned even if {@link Submodule.ignore} is set to {@link SubmoduleIgnore.ALL}.
6895 *
6896 * * {@link IN_HEAD} superproject head contains submodule
6897 * * {@link IN_INDEX} superproject index contains submodule
6898 * * {@link IN_CONFIG} superproject gitmodules has submodule
6899 * * {@link IN_WD} superproject workdir has submodule
6900 *
6901 * The following values will be returned so long as ignore is not {@link SubmoduleIgnore.ALL}.
6902 *
6903 * * {@link INDEX_ADDED} in index, not in head
6904 * * {@link INDEX_DELETED} in head, not in index
6905 * * {@link INDEX_MODIFIED} index and head don't match
6906 * * {@link WD_UNINITIALIZED} workdir contains empty directory
6907 * * {@link WD_ADDED} in workdir, not index
6908 * * {@link WD_DELETED} in index, not workdir
6909 * * {@link WD_MODIFIED} index and workdir head don't match
6910 *
6911 * The following can only be returned if ignore is {@link SubmoduleIgnore.NONE} or {@link SubmoduleIgnore.UNTRACKED}.
6912 *
6913 * * {@link WD_INDEX_MODIFIED} submodule workdir index is dirty
6914 * * {@link WD_WD_MODIFIED} submodule workdir has modified files
6915 *
6916 * Lastly, the following will only be returned for ignore {@link SubmoduleIgnore.NONE}.
6917 *
6918 * * {@link WD_UNTRACKED} wd contains untracked files
6919 */
6920 [CCode(cname = "unsigned int", has_type_id = false, cprefix = "GIT_SUBMODULE_STATUS_")]
6921 public enum SubmoduleStatus {
6922 IN_HEAD,
6923 IN_INDEX,
6924 IN_CONFIG,
6925 IN_WD,
6926 INDEX_ADDED,
6927 INDEX_DELETED,
6928 INDEX_MODIFIED,
6929 WD_UNINITIALIZED,
6930 WD_ADDED,
6931 WD_DELETED,
6932 WD_MODIFIED,
6933 WD_INDEX_MODIFIED,
6934 WD_WD_MODIFIED,
6935 WD_UNTRACKED;
6936 [CCode(cname = "GIT_SUBMODULE_STATUS_IS_UNMODIFIED")]
6937 public bool is_unmodified();
6938 [CCode(cname = "GIT_SUBMODULE_STATUS_IS_WD_DIRTY")]
6939 public bool is_wd_dirty();
6940 }
6941 /**
6942 * Available tracing levels.
6943 *
6944 * When tracing is set to a particular level, callers will be provided
6945 * tracing at the given level and all lower levels.
6946 */
6947 [CCode(cname = "git_trace_level_t", cprefix = "GIT_TRACE_", has_type_id = false)]
6948 public enum Trace {
6949 /**
6950 * No tracing will be performed.
6951 */
6952 NONE,
6953 /**
6954 * Severe errors that may impact the program's execution
6955 */
6956 FATAL,
6957 /**
6958 * Errors that do not impact the program's execution
6959 */
6960 ERROR,
6961 /**
6962 * Warnings that suggest abnormal data
6963 */
6964 WARN,
6965 /**
6966 * Informational messages about program execution
6967 */
6968 INFO,
6969 /**
6970 * Detailed data that allows for debugging
6971 */
6972 DEBUG,
6973 /**
6974 * Exceptionally detailed debugging data
6975 */
6976 TRACE;
6977 /**
6978 * Sets the system tracing configuration to the specified level with the
6979 * specified callback.
6980 *
6981 * When system events occur at a level equal to, or lower than, the given
6982 * level they will be reported to the given callback.
6983 */
6984 [CCode(cname = "git_trace_set")]
6985 public Error setup(Tracer tracer);
6986 }
6987 [CCode(cname = "int", cprefix = "GIT_TRANSPORTFLAGS_", has_type_id = false)]
6988 public enum TransportFlags {
6989 NONE,
6990 /**
6991 * If the connection is secured with SSL/TLS, the authenticity of the
6992 * server certificate should not be verified.
6993 */
6994 NO_CHECK_CERT
6995 }
6996
6997 /**
6998 * Tree traversal modes
6999 */
7000 [CCode(cname = "git_treewalk_mode", cprefix = "GIT_TREEWALK_", has_type_id = false)]
7001 public enum WalkMode {
7002 PRE,
7003 POST
7004 }
7005
7006 [CCode(cname = "git_attr_foreach_cb", has_type_id = false)]
7007 public delegate Error AttributeForEach(string name, string? val);
7008 [CCode(cname = "git_branch_foreach_cb")]
7009 public delegate int Branch(string branch_name, BranchType branch_type);
7010 /**
7011 * Callback for notification of a file during checkout.
7012 *
7013 *
7014 * Notification callbacks are made prior to modifying any files on disk.
7015 *
7016 * @return true to cancel the checkout; false otherwise.
7017 */
7018 [CCode(cname = "git_checkout_notify_cb", has_type_id = false)]
7019 public delegate bool CheckoutNotifier(CheckoutNotify why, string path, diff_file baseline, diff_file target, diff_file workdir);
7020 /**
7021 *
7022 * The implementation of the callback has to respect the
7023 * following rules:
7024 *
7025 * @param content will have to be filled. The maximum number of bytes that
7026 * the buffer can accept per call is the length of the array.
7027 *
7028 * @return The callback is expected to return the number of bytes
7029 * written to content. When there is no more data to stream, the callback
7030 * should return 0. This will prevent it from being invoked anymore. When an
7031 * error occurs, the callback should return -1.
7032 */
7033 [CCode(cname = "git_blob_chunk_cb")]
7034 public delegate int ChunkSource([CCode(array_length_type = "size_t")] uint8[] content);
7035
7036 [CCode(cname = "git_config_foreach_cb")]
7037 public delegate int ConfigForEach(config_entry entry);
7038 /**
7039 * made on files where the index differs from the working
7040 * directory but the rules do not allow update.
7041 *
7042 * All such callbacks will be made before any changes are made to the
7043 * working directory.
7044 * @return true to abort the checkout.
7045 */
7046 public delegate bool Conflict(string conflicting_path, object_id index_id, uint index_mode, uint wd_mode);
7047 /**
7048 * A function which creates a new subtransport for the smart transport
7049 */
7050 [CCode(cname = "git_smart_subtransport_cb", has_target = false)]
7051 public delegate Error CreateSubTransport(out smart_subtransport? subtransport, transport owner);
7052 /**
7053 * Signature of a function which creates a transport
7054 */
7055 [CCode(cname = "git_transport_cb")]
7056 public delegate Error CreateTransport(out transport? transport, Remote owner);
7057
7058 /**
7059 * Signature of a function which acquires a credential object.
7060 *
7061 * @param cred The newly created credential object.
7062 * @param url The resource for which we are demanding a credential.
7063 * @param allowed_types A bitmask stating which cred types are OK to return.
7064 */
7065 [CCode(cname = "git_cred_acquire_cb", has_type_id = false)]
7066 public delegate Error CredAcquire(out cred? cred, string url, CredTypes allowed_types);
7067 [CCode(has_target = false, has_type_id = false)]
7068 public delegate void CredFree(owned cred cred);
7069
7070 /**
7071 * When printing a diff, callback that will be made to output each line of
7072 * text.
7073 * @return true to stop iteration
7074 */
7075 [CCode(cname = "git_diff_data_cb", simple_generics = true, has_target = false, has_type_id = false)]
7076 public delegate bool DiffData<T>(diff_delta delta, diff_range range, DiffLineType line_origin, [CCode(array_length_type = "size_t")] char[] formatted_output, T context);
7077 /**
7078 * When iterating over a diff, callback that will be made per file.
7079 */
7080 [CCode(cname = "git_diff_file_cb", simple_generics = true, has_target = false, has_type_id = false)]
7081 public delegate Error DiffFile<T>(diff_delta delta, float progress, T context);
7082
7083 /**
7084 * When iterating over a diff, callback that will be made per hunk.
7085 */
7086 [CCode(cname = "git_diff_hunk_cb", simple_generics = true, has_target = false, has_type_id = false)]
7087 public delegate Error DiffHunk<T>(diff_delta delta, diff_range range, [CCode(array_length_type = "size_t")] char[] header, T context);
7088
7089 /**
7090 * When iterating over a diff, callback that will be made per text diff
7091 * line.
7092 * @return true to stop iteration
7093 */
7094 [CCode(cname = "git_diff_line_fn", simple_generics = true, has_target = false, has_type_id = false)]
7095 public delegate bool DiffLine<T>(T context, diff_delta delta, DiffLineType line_origin, [CCode(array_length_type = "size_t")] uint8[] content);
7096 /*
7097 * Diff notification callback function.
7098 *
7099 * The callback will be called for each file, just before the {@link
7100 * DeltaType} gets inserted into the diff list.
7101 *
7102 * When the callback:
7103 * - returns < 0, the diff process will be aborted.
7104 * - returns > 0, the delta will not be inserted into the diff list, but the
7105 * diff process continues.
7106 * - returns 0, the delta is inserted into the diff list, and the diff process
7107 * continues.
7108 */
7109 [CCode(cname = "git_diff_notify_cb", has_type_id = false)]
7110 public delegate int DiffNotify(DiffList diff_so_far, diff_delta delta_to_add, string matched_pathspec);
7111
7112 /**
7113 * When printing a diff, callback that will be made to output each line of
7114 * text.
7115 * @return true to stop iteration
7116 */
7117 [CCode(cname = "git_diff_data_cb", has_type_id = false)]
7118 public delegate bool DiffOutput(diff_delta delta, diff_range range, DiffLineType line_origin, [CCode(array_length_type = "size_t")] char[] formatted_output);
7119 [CCode(cname = "git_repository_fetchhead_foreach_cb")]
7120 public delegate bool FetchHeadForEach(string ref_name, string remote_url, object_id id, bool is_merge);
7121
7122 [CCode(cname = "git_treebuilder_filter_cb", has_type_id = false)]
7123 public delegate bool Filter(TreeEntry entry);
7124 [CCode(cname = "git_headlist_cb", has_type_id = false)]
7125 public delegate int Head(remote_head head);
7126 [CCode(cname = "git_repository_mergehead_foreach_cb", has_type_id = false)]
7127 public delegate bool MergeHeadForEach(object_id id);
7128 /**
7129 * Called to process a note.
7130 * @param blob_id id of the blob containing the message
7131 * @param annotated_object_id id of the git object being annotated
7132 */
7133 [CCode(cname = "git_note_foreach_cb", has_type_id = false)]
7134 public delegate Error NoteForEach(object_id blob_id, object_id annotated_object_id);
7135 [CCode(cname = "git_odb_foreach_cb", has_type_id = false)]
7136 public delegate Error ObjectIdForEach(object_id id);
7137 [CCode(cname = "git_packbuilder_foreach_cb", has_type_id = false)]
7138 public delegate int PackBuilderForEach([CCode(array_length_type = "size_t")] uint8[] buffer);
7139 public delegate bool PushForEach(string ref_spec, string msg);
7140 [CCode(cname = "git_checkout_progress_cb")]
7141 public delegate void Progress(string path, size_t completed_steps, size_t total_steps);
7142
7143 /**
7144 * Suggests that the given refdb compress or optimize its references.
7145 *
7146 * This mechanism is implementation specific. (For on-disk reference
7147 * databases, this may pack all loose references.)
7148 */
7149 [CCode(has_target = false, has_type_id = false)]
7150 public delegate Error RefDbCompress(refdb_backend backend);
7151 /**
7152 * Deletes the given reference from the refdb.
7153 */
7154 [CCode(has_target = false, has_type_id = false)]
7155 public delegate Error RefDbDelete(refdb_backend backend, Reference reference);
7156 /**
7157 * Queries the refdb backend to determine if the given ref_name
7158 * exists.
7159 */
7160 [CCode(has_target = false, has_type_id = false)]
7161 public delegate Error RefDbExists(out bool exists, refdb_backend backend, string ref_name);
7162 /**
7163 * Enumerates each reference in the refdb.
7164 */
7165 [CCode(has_target = false, has_type_id = false)]
7166 public delegate Error RefDbForEach(refdb_backend backend, ReferenceType list_flags, ReferenceForEach @foreach);
7167 /**
7168 * Enumerates each reference in the refdb that matches the given glob string.
7169 */
7170 [CCode(has_target = false, has_type_id = false)]
7171 public delegate Error RefDbForEachGlob(refdb_backend backend, string glob, ReferenceType list_flags, ReferenceForEach @foreach);
7172 /**
7173 * Frees any resources held by the refdb.
7174 */
7175 [CCode(has_target = false, has_type_id = false)]
7176 public delegate void RefDbFree(owned refdb_backend backend);
7177 /**
7178 * Queries the refdb backend for a given reference.
7179 */
7180 [CCode(has_target = false, has_type_id = false)]
7181 public delegate Error RefDbLookup(out Reference? reference, refdb_backend backend, string ref_name);
7182 /**
7183 * Writes the given reference to the refdb.
7184 */
7185 [CCode(has_target = false, has_type_id = false)]
7186 public delegate Error RefDbWrite(refdb_backend backend, Reference reference);
7187
7188 [CCode(cname = "git_reference_foreach_cb", has_type_id = false)]
7189 public delegate bool ReferenceForEach(string refname);
7190 [CCode(simple_generics = true, has_type_id = false)]
7191 public delegate void RemoteProgress<T>(uint8[] str, T data);
7192 [CCode(has_target = false, simple_generics = true, has_type_id = false)]
7193 public delegate Error RemoteCompletion<T>(CompletionType type, T data);
7194 [CCode(has_target = false, simple_generics = true, has_type_id = false)]
7195 public delegate Error RemoteUpdateTips<T>(string refname, object_id a, object_id b, T data);
7196 /**
7197 * When iterating over all the stashed states, callback that will be issued
7198 * per entry.
7199 *
7200 * @param index The position within the stash list. 0 points to the most
7201 * recent stashed state.
7202 * @param message The stash message.
7203 * @param stash_id The commit id of the stashed state.
7204 * @return 0 on success, GIT_EUSER on non-zero callback, or error code
7205 */
7206 [CCode(cname = "git_stash_cb")]
7207 public delegate Error StashForEach(size_t index, string message, object_id stash_id);
7208 /**
7209 * Function to receive status on individual files
7210 *
7211 * @param file the relative path to the file from the root of the repository.
7212 */
7213 [CCode(cname = "git_status_cb", has_type_id = false)]
7214 public delegate Error StatusForEach(string file, Status status);
7215 public delegate Error SubmoduleForEach(string name);
7216 [CCode(cname = "git_tag_foreach_cb", has_type_id = false)]
7217 public delegate bool TagForEach(string name, object_id id);
7218 /**
7219 * An instance for a tracing function
7220 */
7221 [CCode(cname = "git_trace_callback", has_type_id = false, has_target = false)]
7222 public delegate void Tracer(Trace level, string msg);
7223 /**
7224 * Type for progress callbacks during indexing.
7225 *
7226 * @param stats Structure containing information about the state of the transfer
7227 * @return an error to cancel the transfer.
7228 */
7229 [CCode(cname = "git_transfer_progress_callback", has_type_id = false)]
7230 public delegate Error TransferProgress(transfer_progress stats);
7231
7232 [CCode(has_target = false, has_type_id = false)]
7233 public delegate void TransportCancel(transport transport);
7234 [CCode(has_target = false, has_type_id = false)]
7235 public delegate Error TransportClose(transport transport);
7236 [CCode(has_target = false, has_type_id = false)]
7237 public delegate Error TransportConnect(transport transport, string url, CredAcquire cred_acquire, Direction direction, TransportFlags flags);
7238 [CCode(has_target = false, has_type_id = false)]
7239 public delegate Error TransportDownloadPack(transport transport, Repository repo, out transfer_progress stats, Progress progress);
7240 [CCode(has_target = false, has_type_id = false)]
7241 public delegate void TransportFree(owned transport? transport);
7242 [CCode(has_target = false, has_type_id = false)]
7243 public delegate bool TransportIsConnected(transport transport);
7244 [CCode(has_target = false, has_type_id = false)]
7245 public delegate Error TransportList(transport transport, Head list);
7246 [CCode(cname = "git_transport_message_cb", has_type_id = false, has_target = false, simple_generics = true)]
7247 public delegate void TransportMessage<T>(uint8[] message, T data);
7248 [CCode(has_target = false, has_type_id = false)]
7249 public delegate Error TransportNegotiatFetch(transport transport, Repository repo, [CCode(array_length_type = "size_t")] remote_head[] refs);
7250 [CCode(has_target = false, has_type_id = false)]
7251 public delegate Error TransportPush(transport transport, Push push);
7252 [CCode(has_target = false, has_type_id = false)]
7253 public delegate Error TransportReadFlags(transport transport, out TransportFlags flags);
7254 [CCode(has_target = false, has_type_id = false)]
7255 public delegate Error TransportSetCallbacks<T>(transport transport, TransportMessage<T> progress, TransportMessage<T> error, T data);
7256
7257 [CCode(has_target = false, has_type_id = false)]
7258 public delegate Error SubTransportAction(out smart_subtransport_stream? stream, smart_subtransport transport, string url, SmartService action);
7259 [CCode(has_target = false, has_type_id = false)]
7260 public delegate Error SubTransportClose(smart_subtransport transport);
7261 [CCode(has_target = false, has_type_id = false)]
7262 public delegate void SubTransportFree(owned smart_subtransport? transport);
7263 [CCode(has_target = false, has_type_id = false)]
7264 public delegate void SubTransportStreamFree(owned smart_subtransport_stream? stream);
7265 [CCode(has_target = false, has_type_id = false)]
7266 public delegate Error SubTransportStreamRead(smart_subtransport_stream stream, [CCode(array_length_type = "size_t")] uint8[] buffer, out size_t bytes_read);
7267 [CCode(has_target = false, has_type_id = false)]
7268 public delegate Error SubTransportStreamWrite(smart_subtransport_stream stream, [CCode(array_length_type = "size_t")] uint8[] buffer);
7269
7270 [CCode(cname = "git_treewalk_cb", has_type_id = false)]
7271 public delegate int TreeWalker(string root, TreeEntry entry);
7272 [CCode(has_target = false)]
7273 public delegate Error Update(string refname, object_id old, object_id @new);
7274
7275 /**
7276 * Clean up message from excess whitespace and make sure that the last line
7277 * ends with a new line.
7278 *
7279 * @param message_out The buffer which will be filled with the cleaned up
7280 * message.
7281 * @param message The message to be prettified.
7282 *
7283 * @param strip_comments remove lines starting with a "#".
7284 */
7285 [CCode(cname = "git_message_prettify")]
7286 public Error prettify_message([CCode(array_length_type = "size_t")] uint8[] message_out, string message, bool strip_comments);
7287
7288 namespace Option {
7289 [CCode(cname = "int", cprefix = "GIT_OPT_")]
7290 private enum _Option {
7291 GET_MWINDOW_SIZE,
7292 SET_MWINDOW_SIZE,
7293 GET_MWINDOW_MAPPED_LIMIT,
7294 SET_MWINDOW_MAPPED_LIMIT,
7295 GET_SEARCH_PATH,
7296 SET_SEARCH_PATH,
7297 GET_ODB_CACHE_SIZE,
7298 SET_ODB_CACHE_SIZE;
7299 [CCode(cname = "git_libgit2_opts")]
7300 public Error opts(...);
7301 }
7302 public size_t get_mwindow_mapped_limit() {
7303 size_t s = 0;
7304 _Option.GET_MWINDOW_MAPPED_LIMIT.opts(out s);
7305 return s;
7306 }
7307 /**
7308 * Set the maximum amount of memory that can be mapped at any time by the
7309 * library.
7310 */
7311 public void set_mwindow_mapped_limit(size_t size) {
7312 _Option.SET_MWINDOW_MAPPED_LIMIT.opts(size);
7313 }
7314 /**
7315 * Set the maximum mmap window size.
7316 */
7317 public size_t get_mwindow_size() {
7318 size_t s = 0;
7319 _Option.GET_MWINDOW_SIZE.opts(out s);
7320 return s;
7321 }
7322 public void set_mwindow_size(size_t size) {
7323 _Option.SET_MWINDOW_SIZE.opts(size);
7324 }
7325 /**
7326 * Get the size of the libgit2 odb cache.
7327 */
7328 public size_t get_odb_cache_size() {
7329 size_t s = 0;
7330 _Option.GET_ODB_CACHE_SIZE.opts(out s);
7331 return s;
7332 }
7333 /**
7334 * Set the size of the of the libgit2 odb cache.
7335 *
7336 * This needs to be done before {@link Repository.open} is called, since
7337 * it initializes the odb layer. Defaults to 128.
7338 */
7339 public void set_odb_cache_size(size_t size = 128) {
7340 _Option.SET_ODB_CACHE_SIZE.opts(size);
7341 }
7342 /**
7343 * Set the search path for a given level of config data.
7344 *
7345 * @param level must be one of {@link ConfigLevel.SYSTEM},
7346 * {@link ConfigLevel_GLOBAL}, or {@link ConfigLevel.XDG}.
7347 */
7348 public string get_search_path(ConfigLevel level) {
7349 uint8[] buffer = new uint8[64];
7350 while (_Option.GET_SEARCH_PATH.opts(level, (void*)buffer, (size_t) buffer.length) == Error.BUFS) {
7351 buffer = new uint8[buffer.length * 2];
7352 }
7353 return ((string)buffer).dup();
7354 }
7355 public void set_search_path(ConfigLevel level, string path) {
7356 _Option.SET_SEARCH_PATH.opts(level, path);
7357 }
7358 }
7359
7360 /**
7361 * Set the error message to a special value for memory allocation failure.
7362 *
7363 * The normal {@link ErrClass.raise} function attempts to duplicate the
7364 * string that is passed in. This is not a good idea when the error in
7365 * question is a memory allocation failure. That circumstance has a special
7366 * setter function that sets the error string to a known and statically
7367 * allocated internal value.
7368 */
7369 [CCode(cname = "giterr_set_oom")]
7370 public void raise_oom();
7371
7372
7373 [CCode(cname = "char*", has_type_id = false)]
7374 [SimpleType]
7375 private struct unstr {
7376 [CCode(cname = "strdup")]
7377 public string dup();
7378 }
7379 }
7380
7381
7382