/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#ifndef INCLUDE_git_types_h__

#define INCLUDE_git_types_h__

#include "common.h"

/**

 * @file git2/types.h

 * @brief libgit2 base & compatibility types

 * @ingroup Git

 * @{

 */

GIT_BEGIN_DECL

/**

 * Cross-platform compatibility types for off_t / time_t

 *

 * NOTE: This needs to be in a public header so that both the library

 * implementation and client applications both agree on the same types.

 * Otherwise we get undefined behavior.

 *

 * Use the "best" types that each platform provides. Currently we truncate

 * these intermediate representations for compatibility with the git ABI, but

 * if and when it changes to support 64 bit types, our code will naturally

 * adapt.

 * NOTE: These types should match those that are returned by our internal

 * stat() functions, for all platforms.

 */

#include <sys/types.h>

#ifdef __amigaos4__

#include <stdint.h>

#endif

#if defined(_MSC_VER)

typedef __int64 git_off_t;

typedef __time64_t git_time_t;

#elif defined(__MINGW32__)

typedef off64_t git_off_t;

typedef __time64_t git_time_t;

#elif defined(__HAIKU__)

typedef __haiku_std_int64 git_off_t;

typedef __haiku_std_int64 git_time_t;

#else /* POSIX */

/*

 * Note: Can't use off_t since if a client program includes <sys/types.h>

 * before us (directly or indirectly), they'll get 32 bit off_t in their client

 * app, even though /we/ define _FILE_OFFSET_BITS=64.

 */

typedef int64_t git_off_t;

typedef int64_t git_time_t;

#endif

/** Basic type (loose or packed) of any Git object. */

typedef enum {

	GIT_OBJ_ANY = -2,		/**< Object can be any of the following */

	GIT_OBJ_BAD = -1,		/**< Object is invalid. */

	GIT_OBJ__EXT1 = 0,		/**< Reserved for future use. */

	GIT_OBJ_COMMIT = 1,		/**< A commit object. */

	GIT_OBJ_TREE = 2,		/**< A tree (directory listing) object. */

	GIT_OBJ_BLOB = 3,		/**< A file revision object. */

	GIT_OBJ_TAG = 4,		/**< An annotated tag object. */

	GIT_OBJ__EXT2 = 5,		/**< Reserved for future use. */

	GIT_OBJ_OFS_DELTA = 6, /**< A delta, base is given by an offset. */

	GIT_OBJ_REF_DELTA = 7, /**< A delta, base is given by object id. */

} git_otype;

/** An open object database handle. */

typedef struct git_odb git_odb;

/** A custom backend in an ODB */

typedef struct git_odb_backend git_odb_backend;

/** An object read from the ODB */

typedef struct git_odb_object git_odb_object;

/** A stream to read/write from the ODB */

typedef struct git_odb_stream git_odb_stream;

/** A stream to write a packfile to the ODB */

typedef struct git_odb_writepack git_odb_writepack;

/** An open refs database handle. */

typedef struct git_refdb git_refdb;

/** A custom backend for refs */

typedef struct git_refdb_backend git_refdb_backend;

/**

 * Representation of an existing git repository,

 * including all its object contents

 */

typedef struct git_repository git_repository;

/** Representation of a working tree */

typedef struct git_worktree git_worktree;

/** Representation of a generic object in a repository */

typedef struct git_object git_object;

/** Representation of an in-progress walk through the commits in a repo */

typedef struct git_revwalk git_revwalk;

/** Parsed representation of a tag object. */

typedef struct git_tag git_tag;

/** In-memory representation of a blob object. */

typedef struct git_blob git_blob;

/** Parsed representation of a commit object. */

typedef struct git_commit git_commit;

/** Representation of each one of the entries in a tree object. */

typedef struct git_tree_entry git_tree_entry;

/** Representation of a tree object. */

typedef struct git_tree git_tree;

/** Constructor for in-memory trees */

typedef struct git_treebuilder git_treebuilder;

/** Memory representation of an index file. */

typedef struct git_index git_index;

/** An iterator for conflicts in the index. */

typedef struct git_index_conflict_iterator git_index_conflict_iterator;

/** Memory representation of a set of config files */

typedef struct git_config git_config;

/** Interface to access a configuration file */

typedef struct git_config_backend git_config_backend;

/** Representation of a reference log entry */

typedef struct git_reflog_entry git_reflog_entry;

/** Representation of a reference log */

typedef struct git_reflog git_reflog;

/** Representation of a git note */

typedef struct git_note git_note;

/** Representation of a git packbuilder */

typedef struct git_packbuilder git_packbuilder;

/** Time in a signature */

typedef struct git_time {

	git_time_t time; /**< time in seconds from epoch */

	int offset; /**< timezone offset, in minutes */

} git_time;

/** An action signature (e.g. for committers, taggers, etc) */

typedef struct git_signature {

	char *name; /**< full name of the author */

	char *email; /**< email of the author */

	git_time when; /**< time when the action happened */

} git_signature;

/** In-memory representation of a reference. */

typedef struct git_reference git_reference;

/** Iterator for references */

typedef struct git_reference_iterator  git_reference_iterator;

/** Transactional interface to references */

typedef struct git_transaction git_transaction;

/** Annotated commits, the input to merge and rebase. */

typedef struct git_annotated_commit git_annotated_commit;

/** Merge result */

typedef struct git_merge_result git_merge_result;

/** Representation of a status collection */

typedef struct git_status_list git_status_list;

/** Representation of a rebase */

typedef struct git_rebase git_rebase;

/** Basic type of any Git reference. */

typedef enum {

	GIT_REF_INVALID = 0, /**< Invalid reference */

	GIT_REF_OID = 1, /**< A reference which points at an object id */

	GIT_REF_SYMBOLIC = 2, /**< A reference which points at another reference */

	GIT_REF_LISTALL = GIT_REF_OID|GIT_REF_SYMBOLIC,

} git_ref_t;

/** Basic type of any Git branch. */

typedef enum {

	GIT_BRANCH_LOCAL = 1,

	GIT_BRANCH_REMOTE = 2,

	GIT_BRANCH_ALL = GIT_BRANCH_LOCAL|GIT_BRANCH_REMOTE,

} git_branch_t;

/** Valid modes for index and tree entries. */

typedef enum {

	GIT_FILEMODE_UNREADABLE          = 0000000,

	GIT_FILEMODE_TREE                = 0040000,

	GIT_FILEMODE_BLOB                = 0100644,

	GIT_FILEMODE_BLOB_EXECUTABLE     = 0100755,

	GIT_FILEMODE_LINK                = 0120000,

	GIT_FILEMODE_COMMIT              = 0160000,

} git_filemode_t;

/*

 * A refspec specifies the mapping between remote and local reference

 * names when fetch or pushing.

 */

typedef struct git_refspec git_refspec;

/**

 * Git's idea of a remote repository. A remote can be anonymous (in

 * which case it does not have backing configuration entires).

 */

typedef struct git_remote git_remote;

/**

 * Interface which represents a transport to communicate with a

 * remote.

 */

typedef struct git_transport git_transport;

/**

 * Preparation for a push operation. Can be used to configure what to

 * push and the level of parallelism of the packfile builder.

 */

typedef struct git_push git_push;

/* documentation in the definition */

typedef struct git_remote_head git_remote_head;

typedef struct git_remote_callbacks git_remote_callbacks;

/**

 * This is passed as the first argument to the callback to allow the

 * user to see the progress.

 *

 * - total_objects: number of objects in the packfile being downloaded

 * - indexed_objects: received objects that have been hashed

 * - received_objects: objects which have been downloaded

 * - local_objects: locally-available objects that have been injected

 *    in order to fix a thin pack.

 * - received-bytes: size of the packfile received up to now

 */

typedef struct git_transfer_progress {

	unsigned int total_objects;

	unsigned int indexed_objects;

	unsigned int received_objects;

	unsigned int local_objects;

	unsigned int total_deltas;

	unsigned int indexed_deltas;

	size_t received_bytes;

} git_transfer_progress;

/**

 * Type for progress callbacks during indexing.  Return a value less than zero

 * to cancel the transfer.

 *

 * @param stats Structure containing information about the state of the transfer

 * @param payload Payload provided by caller

 */

typedef int (*git_transfer_progress_cb)(const git_transfer_progress *stats, void *payload);

/**

 * Type for messages delivered by the transport.  Return a negative value

 * to cancel the network operation.

 *

 * @param str The message from the transport

 * @param len The length of the message

 * @param payload Payload provided by the caller

 */

typedef int (*git_transport_message_cb)(const char *str, int len, void *payload);

/**

 * Type of host certificate structure that is passed to the check callback

 */

typedef enum git_cert_t {

	/**

	 * No information about the certificate is available. This may

	 * happen when using curl.

	 */

	GIT_CERT_NONE,

        /**

         * The `data` argument to the callback will be a pointer to

         * the DER-encoded data.

         */

	GIT_CERT_X509,

        /**

         * The `data` argument to the callback will be a pointer to a

         * `git_cert_hostkey` structure.

         */

	GIT_CERT_HOSTKEY_LIBSSH2,

	/**

	 * The `data` argument to the callback will be a pointer to a

	 * `git_strarray` with `name:content` strings containing

	 * information about the certificate. This is used when using

	 * curl.

	 */

	GIT_CERT_STRARRAY,

} git_cert_t;

/**

 * Parent type for `git_cert_hostkey` and `git_cert_x509`.

 */

typedef struct {

	/**

	 * Type of certificate. A `GIT_CERT_` value.

	 */

	git_cert_t cert_type;

} git_cert;

/**

 * Callback for the user's custom certificate checks.

 *

 * @param cert The host certificate

 * @param valid Whether the libgit2 checks (OpenSSL or WinHTTP) think

 * this certificate is valid

 * @param host Hostname of the host libgit2 connected to

 * @param payload Payload provided by the caller

 */

typedef int (*git_transport_certificate_check_cb)(git_cert *cert, int valid, const char *host, void *payload);

/**

 * Opaque structure representing a submodule.

 */

typedef struct git_submodule git_submodule;

/**

 * Submodule update values

 *

 * These values represent settings for the `submodule.$name.update`

 * configuration value which says how to handle `git submodule update` for

 * this submodule.  The value is usually set in the ".gitmodules" file and

 * copied to ".git/config" when the submodule is initialized.

 *

 * You can override this setting on a per-submodule basis with

 * `git_submodule_set_update()` and write the changed value to disk using

 * `git_submodule_save()`.  If you have overwritten the value, you can

 * revert it by passing `GIT_SUBMODULE_UPDATE_RESET` to the set function.

 *

 * The values are:

 *

 * - GIT_SUBMODULE_UPDATE_CHECKOUT: the default; when a submodule is

 *   updated, checkout the new detached HEAD to the submodule directory.

 * - GIT_SUBMODULE_UPDATE_REBASE: update by rebasing the current checked

 *   out branch onto the commit from the superproject.

 * - GIT_SUBMODULE_UPDATE_MERGE: update by merging the commit in the

 *   superproject into the current checkout out branch of the submodule.

 * - GIT_SUBMODULE_UPDATE_NONE: do not update this submodule even when

 *   the commit in the superproject is updated.

 * - GIT_SUBMODULE_UPDATE_DEFAULT: not used except as static initializer

 *   when we don't want any particular update rule to be specified.

 */

typedef enum {

	GIT_SUBMODULE_UPDATE_CHECKOUT = 1,

	GIT_SUBMODULE_UPDATE_REBASE   = 2,

	GIT_SUBMODULE_UPDATE_MERGE    = 3,

	GIT_SUBMODULE_UPDATE_NONE     = 4,

	GIT_SUBMODULE_UPDATE_DEFAULT  = 0

} git_submodule_update_t;

/**

 * Submodule ignore values

 *

 * These values represent settings for the `submodule.$name.ignore`

 * configuration value which says how deeply to look at the working

 * directory when getting submodule status.

 *

 * You can override this value in memory on a per-submodule basis with

 * `git_submodule_set_ignore()` and can write the changed value to disk

 * with `git_submodule_save()`.  If you have overwritten the value, you

 * can revert to the on disk value by using `GIT_SUBMODULE_IGNORE_RESET`.

 *

 * The values are:

 *

 * - GIT_SUBMODULE_IGNORE_UNSPECIFIED: use the submodule's configuration

 * - GIT_SUBMODULE_IGNORE_NONE: don't ignore any change - i.e. even an

 *   untracked file, will mark the submodule as dirty.  Ignored files are

 *   still ignored, of course.

 * - GIT_SUBMODULE_IGNORE_UNTRACKED: ignore untracked files; only changes

 *   to tracked files, or the index or the HEAD commit will matter.

 * - GIT_SUBMODULE_IGNORE_DIRTY: ignore changes in the working directory,

 *   only considering changes if the HEAD of submodule has moved from the

 *   value in the superproject.

 * - GIT_SUBMODULE_IGNORE_ALL: never check if the submodule is dirty

 * - GIT_SUBMODULE_IGNORE_DEFAULT: not used except as static initializer

 *   when we don't want any particular ignore rule to be specified.

 */

typedef enum {

	GIT_SUBMODULE_IGNORE_UNSPECIFIED  = -1, /**< use the submodule's configuration */

	GIT_SUBMODULE_IGNORE_NONE      = 1,  /**< any change or untracked == dirty */

	GIT_SUBMODULE_IGNORE_UNTRACKED = 2,  /**< dirty if tracked files change */

	GIT_SUBMODULE_IGNORE_DIRTY     = 3,  /**< only dirty if HEAD moved */

	GIT_SUBMODULE_IGNORE_ALL       = 4,  /**< never dirty */

} git_submodule_ignore_t;

/**

 * Options for submodule recurse.

 *

 * Represent the value of `submodule.$name.fetchRecurseSubmodules`

 *

 * * GIT_SUBMODULE_RECURSE_NO    - do no recurse into submodules

 * * GIT_SUBMODULE_RECURSE_YES   - recurse into submodules

 * * GIT_SUBMODULE_RECURSE_ONDEMAND - recurse into submodules only when

 *                                    commit not already in local clone

 */

typedef enum {

	GIT_SUBMODULE_RECURSE_NO = 0,

	GIT_SUBMODULE_RECURSE_YES = 1,

	GIT_SUBMODULE_RECURSE_ONDEMAND = 2,

} git_submodule_recurse_t;

/** A type to write in a streaming fashion, for example, for filters. */

typedef struct git_writestream git_writestream;

struct git_writestream {

	int (*write)(git_writestream *stream, const char *buffer, size_t len);

	int (*close)(git_writestream *stream);

	void (*free)(git_writestream *stream);

};

/** @} */

GIT_END_DECL

#endif