svn_types.h

Go to the documentation of this file.

#ifndef SVN_TYPES_H
#define SVN_TYPES_H

/* ### this should go away, but it causes too much breakage right now */
#include <stdlib.h>
#include <limits.h> /* for ULONG_MAX */

#include <apr.h>         /* for apr_size_t, apr_int64_t, ... */
#include <apr_errno.h>   /* for apr_status_t */
#include <apr_pools.h>   /* for apr_pool_t */
#include <apr_hash.h>    /* for apr_hash_t */
#include <apr_tables.h>  /* for apr_array_push() */
#include <apr_time.h>    /* for apr_time_t */
#include <apr_strings.h> /* for apr_atoi64() */

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */



#ifndef SVN_DEPRECATED
# if !defined(SWIGPERL) && !defined(SWIGPYTHON) && !defined(SWIGRUBY)
#  if defined(__GNUC__) && (__GNUC__ >= 4 || (__GNUC__==3 && __GNUC_MINOR__>=1))
#   define SVN_DEPRECATED __attribute__((deprecated))
#  elif defined(_MSC_VER) && _MSC_VER >= 1300
#   define SVN_DEPRECATED __declspec(deprecated)
#  else
#   define SVN_DEPRECATED
#  endif
# else
#  define SVN_DEPRECATED
# endif
#endif


#ifndef SVN_UNALIGNED_ACCESS_IS_OK
# if defined(_M_IX86) || defined(i386) \
     || defined(_M_X64) || defined(__x86_64) \
     || defined(__powerpc__) || defined(__ppc__)
#  define SVN_UNALIGNED_ACCESS_IS_OK 1
# else
#  define SVN_UNALIGNED_ACCESS_IS_OK 0
# endif
#endif



typedef int svn_boolean_t;

#ifndef TRUE

#define TRUE 1
#endif /* TRUE */

#ifndef FALSE

#define FALSE 0
#endif /* FALSE */



typedef struct svn_error_t
{
  apr_status_t apr_err;

  const char *message;

  struct svn_error_t *child;

  apr_pool_t *pool;

  const char *file;

  long line;

} svn_error_t;



/* See svn_version.h.
   Defined here to avoid including svn_version.h from all public headers. */
typedef struct svn_version_t svn_version_t;



#ifndef APR_ARRAY_IDX
#define APR_ARRAY_IDX(ary,i,type) (((type *)(ary)->elts)[i])
#endif

#ifndef APR_ARRAY_PUSH
#define APR_ARRAY_PUSH(ary,type) (*((type *)apr_array_push(ary)))
#endif


const void *
svn__apr_hash_index_key(const apr_hash_index_t *hi);

apr_ssize_t
svn__apr_hash_index_klen(const apr_hash_index_t *hi);

void *
svn__apr_hash_index_val(const apr_hash_index_t *hi);


/* ### These fixes should go into APR. */
#ifndef WIN32
#define SVN__APR_STATUS_IS_ENOTDIR(s)  APR_STATUS_IS_ENOTDIR(s)
#else
#define SVN__APR_STATUS_IS_ENOTDIR(s)  (APR_STATUS_IS_ENOTDIR(s) \
                      || ((s) == APR_OS_START_SYSERR + ERROR_DIRECTORY) \
                      || ((s) == APR_OS_START_SYSERR + ERROR_INVALID_NAME))
#endif


typedef enum svn_node_kind_t
{
  svn_node_none,

  svn_node_file,

  svn_node_dir,

  svn_node_unknown,

  svn_node_symlink
} svn_node_kind_t;

const char *
svn_node_kind_to_word(svn_node_kind_t kind);

svn_node_kind_t
svn_node_kind_from_word(const char *word);


typedef enum svn_tristate_t
{
  svn_tristate_false = 2,
  svn_tristate_true,
  svn_tristate_unknown
} svn_tristate_t;

const char *
svn_tristate__to_word(svn_tristate_t tristate);

svn_tristate_t
svn_tristate__from_word(const char * word);




typedef long int svn_revnum_t;

#define SVN_IS_VALID_REVNUM(n) ((n) >= 0)

#define SVN_INVALID_REVNUM ((svn_revnum_t) -1)

#define SVN_IGNORED_REVNUM ((svn_revnum_t) -1)

#define SVN_STR_TO_REV(str) ((svn_revnum_t) atol(str))

svn_error_t *
svn_revnum_parse(svn_revnum_t *rev,
                 const char *str,
                 const char **endptr);

#define SVN_REVNUM_T_FMT "ld"



typedef apr_int64_t svn_filesize_t;

#define SVN_INVALID_FILESIZE ((svn_filesize_t) -1)

#define SVN_FILESIZE_T_FMT APR_INT64_T_FMT

#ifndef DOXYGEN_SHOULD_SKIP_THIS
/* Parse a base-10 numeric string into a 64-bit unsigned numeric value. */
/* NOTE: Private. For use by Subversion's own code only. See issue #1644. */
/* FIXME: APR should supply a function to do this, such as "apr_atoui64". */
#define svn__atoui64(X) ((apr_uint64_t) apr_atoi64(X))
#endif



enum svn_recurse_kind
{
  svn_nonrecursive = 1,
  svn_recursive
};

typedef enum svn_depth_t
{
  /* The order of these depths is important: the higher the number,
     the deeper it descends.  This allows us to compare two depths
     numerically to decide which should govern. */

  svn_depth_unknown    = -2,

  svn_depth_exclude    = -1,

  svn_depth_empty      =  0,

  svn_depth_files      =  1,

  svn_depth_immediates =  2,

  svn_depth_infinity   =  3

} svn_depth_t;

const char *
svn_depth_to_word(svn_depth_t depth);

svn_depth_t
svn_depth_from_word(const char *word);

#define SVN_DEPTH_INFINITY_OR_FILES(recurse) \
  ((recurse) ? svn_depth_infinity : svn_depth_files)

#define SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse) \
  ((recurse) ? svn_depth_infinity : svn_depth_immediates)

#define SVN_DEPTH_INFINITY_OR_EMPTY(recurse) \
  ((recurse) ? svn_depth_infinity : svn_depth_empty)

#define SVN_DEPTH_IS_RECURSIVE(depth)                              \
  ((depth) == svn_depth_infinity || (depth) == svn_depth_unknown)



#define SVN_DIRENT_KIND        0x00001

#define SVN_DIRENT_SIZE        0x00002

#define SVN_DIRENT_HAS_PROPS   0x00004

#define SVN_DIRENT_CREATED_REV 0x00008

#define SVN_DIRENT_TIME        0x00010

#define SVN_DIRENT_LAST_AUTHOR 0x00020

#define SVN_DIRENT_ALL ~((apr_uint32_t ) 0)

typedef struct svn_dirent_t
{
  svn_node_kind_t kind;

  svn_filesize_t size;

  svn_boolean_t has_props;

  svn_revnum_t created_rev;

  apr_time_t time;

  const char *last_author;

  /* IMPORTANT: If you extend this struct, check svn_dirent_dup(). */
} svn_dirent_t;

svn_dirent_t *
svn_dirent_dup(const svn_dirent_t *dirent,
               apr_pool_t *pool);

svn_dirent_t *
svn_dirent_create(apr_pool_t *result_pool);


#define SVN_KEYWORD_MAX_LEN    255

#define SVN_KEYWORD_REVISION_LONG    "LastChangedRevision"

#define SVN_KEYWORD_REVISION_SHORT   "Rev"

#define SVN_KEYWORD_REVISION_MEDIUM  "Revision"

#define SVN_KEYWORD_DATE_LONG        "LastChangedDate"

#define SVN_KEYWORD_DATE_SHORT       "Date"

#define SVN_KEYWORD_AUTHOR_LONG      "LastChangedBy"

#define SVN_KEYWORD_AUTHOR_SHORT     "Author"

#define SVN_KEYWORD_URL_LONG         "HeadURL"

#define SVN_KEYWORD_URL_SHORT        "URL"

#define SVN_KEYWORD_ID               "Id"

#define SVN_KEYWORD_HEADER           "Header"


typedef struct svn_commit_info_t
{
  svn_revnum_t revision;

  const char *date;

  const char *author;

  const char *post_commit_err;

  const char *repos_root;

} svn_commit_info_t;

svn_commit_info_t *
svn_create_commit_info(apr_pool_t *pool);

svn_commit_info_t *
svn_commit_info_dup(const svn_commit_info_t *src_commit_info,
                    apr_pool_t *pool);



typedef struct svn_log_changed_path2_t
{
  char action;

  const char *copyfrom_path;

  svn_revnum_t copyfrom_rev;

  svn_node_kind_t node_kind;

  svn_tristate_t text_modified;

  svn_tristate_t props_modified;

  /* NOTE: Add new fields at the end to preserve binary compatibility.
     Also, if you add fields here, you have to update
     svn_log_changed_path2_dup(). */
} svn_log_changed_path2_t;

svn_log_changed_path2_t *
svn_log_changed_path2_create(apr_pool_t *pool);

svn_log_changed_path2_t *
svn_log_changed_path2_dup(const svn_log_changed_path2_t *changed_path,
                          apr_pool_t *pool);

typedef struct svn_log_changed_path_t
{
  char action;

  const char *copyfrom_path;

  svn_revnum_t copyfrom_rev;

} svn_log_changed_path_t;

SVN_DEPRECATED
svn_log_changed_path_t *
svn_log_changed_path_dup(const svn_log_changed_path_t *changed_path,
                         apr_pool_t *pool);

typedef struct svn_log_entry_t
{
  apr_hash_t *changed_paths;

  svn_revnum_t revision;

  apr_hash_t *revprops;

  svn_boolean_t has_children;

  apr_hash_t *changed_paths2;

  svn_boolean_t non_inheritable;

  svn_boolean_t subtractive_merge;

  /* NOTE: Add new fields at the end to preserve binary compatibility.
     Also, if you add fields here, you have to update
     svn_log_entry_dup(). */
} svn_log_entry_t;

svn_log_entry_t *
svn_log_entry_create(apr_pool_t *pool);

svn_log_entry_t *
svn_log_entry_dup(const svn_log_entry_t *log_entry, apr_pool_t *pool);

typedef svn_error_t *(*svn_log_entry_receiver_t)(
  void *baton,
  svn_log_entry_t *log_entry,
  apr_pool_t *pool);

typedef svn_error_t *(*svn_log_message_receiver_t)(
  void *baton,
  apr_hash_t *changed_paths,
  svn_revnum_t revision,
  const char *author,
  const char *date,  /* use svn_time_from_cstring() if need apr_time_t */
  const char *message,
  apr_pool_t *pool);



typedef svn_error_t *(*svn_commit_callback2_t)(
  const svn_commit_info_t *commit_info,
  void *baton,
  apr_pool_t *pool);

typedef svn_error_t *(*svn_commit_callback_t)(
  svn_revnum_t new_revision,
  const char *date,
  const char *author,
  void *baton);



#define SVN_STREAM_CHUNK_SIZE 102400

#ifndef DOXYGEN_SHOULD_SKIP_THIS
/*
 * The maximum amount we (ideally) hold in memory at a time when
 * processing a stream of data.
 *
 * For example, when copying data from one stream to another, do it in
 * blocks of this size.
 *
 * NOTE: This is an internal macro, put here for convenience.
 * No public API may depend on the particular value of this macro.
 */
#define SVN__STREAM_CHUNK_SIZE 16384
#endif

/* FIXME: Should this be the same as SVN_STREAM_CHUNK_SIZE? */
#define SVN_MAX_OBJECT_SIZE (((apr_size_t) -1) / 2)



/* ### Note: despite being about mime-TYPES, these probably don't
 * ### belong in svn_types.h.  However, no other header is more
 * ### appropriate, and didn't feel like creating svn_validate.h for
 * ### so little.
 */

svn_error_t *
svn_mime_type_validate(const char *mime_type,
                       apr_pool_t *pool);

svn_boolean_t
svn_mime_type_is_binary(const char *mime_type);



typedef svn_error_t *(*svn_cancel_func_t)(void *cancel_baton);



typedef struct svn_lock_t
{
  const char *path;              
  const char *token;             
  const char *owner;             
  const char *comment;           
  svn_boolean_t is_dav_comment;  
  apr_time_t creation_date;      
  apr_time_t expiration_date;    
} svn_lock_t;

svn_lock_t *
svn_lock_create(apr_pool_t *pool);

svn_lock_t *
svn_lock_dup(const svn_lock_t *lock, apr_pool_t *pool);



const char *
svn_uuid_generate(apr_pool_t *pool);



typedef struct svn_merge_range_t
{
  svn_revnum_t start;
  svn_revnum_t end;

  svn_boolean_t inheritable;
} svn_merge_range_t;

svn_merge_range_t *
svn_merge_range_dup(const svn_merge_range_t *range, apr_pool_t *pool);

svn_boolean_t
svn_merge_range_contains_rev(const svn_merge_range_t *range, svn_revnum_t rev);



typedef struct svn_location_segment_t
{
  svn_revnum_t range_start;
  svn_revnum_t range_end;

  const char *path;

} svn_location_segment_t;

typedef svn_error_t *(*svn_location_segment_receiver_t)(
  svn_location_segment_t *segment,
  void *baton,
  apr_pool_t *pool);

svn_location_segment_t *
svn_location_segment_dup(const svn_location_segment_t *segment,
                         apr_pool_t *pool);


typedef unsigned long svn_linenum_t;

#define SVN_LINENUM_MAX_VALUE ULONG_MAX



#ifdef __cplusplus
}
#endif /* __cplusplus */


/*
 * Everybody and their brother needs to deal with svn_error_t, the error
 * codes, and whatever else. While they *should* go and include svn_error.h
 * in order to do that... bah. Let's just help everybody out and include
 * that header whenever somebody grabs svn_types.h.
 *
 * Note that we do this at the END of this header so that its contents
 * are available to svn_error.h (our guards will prevent the circular
 * include). We also need to do the include *outside* of the cplusplus
 * guard.
 */
#include "svn_error.h"


/*
 * Subversion developers may want to use some additional debugging facilities
 * while working on the code. We'll pull that in here, so individual source
 * files don't have to include this header manually.
 */
#ifdef SVN_DEBUG
#include "private/svn_debug.h"
#endif


#endif /* SVN_TYPES_H */