/*
 * svn_client.h :  public interface for libsvn_client
 *
 * ====================================================================
 * Copyright (c) 2000-2002 CollabNet.  All rights reserved.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution.  The terms
 * are also available at http://subversion.tigris.org/license-1.html.
 * If newer versions of this license are posted there, you may use a
 * newer version instead, at your option.
 *
 * This software consists of voluntary contributions made by many
 * individuals.  For exact contribution history, see the revision
 * history and logs, available at http://subversion.tigris.org/.
 * ====================================================================
 */


/*** Includes ***/

/* 
 * Requires:  The working copy library and repository access library.
 * Provides:  Broad wrappers around working copy library functionality.
 * Used By:   Client programs.
 */

#ifndef SVN_CLIENT_H
#define SVN_CLIENT_H

#include <apr_tables.h>
#include "svn_types.h"
#include "svn_wc.h"
#include "svn_ra.h"
#include "svn_string.h"
#include "svn_error.h"


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


/* ### TODO:  Multiple Targets

    - Up for debate:  an update on multiple targets is *not* atomic.
    Right now, svn_client_update only takes one path.  What's
    debatable is whether this should ever change.  On the one hand,
    it's kind of losing to have the client application loop over
    targets and call svn_client_update() on each one;  each call to
    update initializes a whole new repository session (network
    overhead, etc.)  On the other hand, it's this is a very simple
    implementation, and allows for the possibility that different
    targets may come from different repositories.  */


/* Various ways of specifying revisions. 
 *   
 * Note:
 * In contexts where local mods are relevant, the `working' kind
 * refers to the uncommitted "working" revision, which may be modified
 * with respect to its base revision.  In other contexts, `working'
 * should behave the same as `committed' or `current'.
 */
enum svn_client_revision_kind {
  svn_client_revision_unspecified,   /* No revision information given. */
  svn_client_revision_number,        /* revision given as number */
  svn_client_revision_date,          /* revision given as date */
  svn_client_revision_committed,     /* rev of most recent change */
  svn_client_revision_previous,      /* (rev of most recent change) - 1 */
  svn_client_revision_base,          /* .svn/entries current revision */
  svn_client_revision_working,       /* current, plus local mods */
  svn_client_revision_head           /* repository youngest */
};


/* A revision, specified in one of `svn_client_revision_kind' ways. */
typedef struct svn_client_revision_t {
  enum svn_client_revision_kind kind;
  union {
    svn_revnum_t number;
    apr_time_t date;
  } value;
} svn_client_revision_t;


/*** Authentication stuff -- new M4 Edition  ***/

/*  The new authentication system allows the RA layer to "pull"
    information as needed from libsvn_client.  See svn_ra.h */

/*  A callback function type defined by the top-level client
    application (the user of libsvn_client.)

    If libsvn_client is unable to retrieve certain authorization
    information, it can use this callback; the application will then
    directly query the user with PROMPT and return the answer in INFO,
    allocated in POOL.  BATON is provided at the same time as the
    callback, and HIDE indicates that the user's answer should not be
    displayed on the screen. */
typedef svn_error_t *(*svn_client_prompt_t)
       (char **info,
        const char *prompt,
        svn_boolean_t hide,
        void *baton,
        apr_pool_t *pool);


/* This is a baton that contains information from the calling
   application, passed to libsvn_client to aid in authentication. 

   Applications must build and pass one of these to any routine that
   may require authentication.  */
typedef struct svn_client_auth_baton_t
{
  /* auth info that the app -may- already have, e.g. from argv[] */
  char *username;    
  char *password; 
  
  /* a callback provided by the app layer, for prompting the user */
  svn_client_prompt_t prompt_callback;
  void *prompt_baton;

  /* if it's ok to overwrite wc auth info */
  svn_boolean_t overwrite;

} svn_client_auth_baton_t;


/* This is a structure which stores a filename and a hash of property
   names and values. */

typedef struct svn_client_proplist_item_s
{
  /* The name of the node on which these properties are set. */
  svn_stringbuf_t *node_name;  

  /* A hash of (const char *) property names, and (svn_stringbuf_t *) property
     values. */
  apr_hash_t *prop_hash;

} svn_client_proplist_item_t;


/* Information about commits passed back to client from this module. */
typedef struct svn_client_commit_info_t
{
  svn_revnum_t revision; /* just-committed revision. */
  const char *date;      /* server-side date of the commit. */
  const char *author;    /* author of the commit. */
} svn_client_commit_info_t;


/* State flags for use with the svn_client_commit_item_t structure
   (see the note about the namespace for that structure, which also
   applies to these flags). */
#define SVN_CLIENT_COMMIT_ITEM_ADD         0x01
#define SVN_CLIENT_COMMIT_ITEM_DELETE      0x02
#define SVN_CLIENT_COMMIT_ITEM_TEXT_MODS   0x04
#define SVN_CLIENT_COMMIT_ITEM_PROP_MODS   0x08
#define SVN_CLIENT_COMMIT_ITEM_IS_COPY     0x10


/* The commit candidate structure. */
typedef struct svn_client_commit_item_t
{
  svn_stringbuf_t *path;         /* absolute working-copy path of item */
  svn_node_kind_t kind;          /* node kind (dir, file) */
  svn_stringbuf_t *url;          /* commit url for this item */
  svn_revnum_t revision;         /* revision (copyfrom-rev if _IS_COPY) */
  svn_stringbuf_t *copyfrom_url; /* copyfrom-url */
  apr_byte_t state_flags;        /* state flags */

} svn_client_commit_item_t;


/* Callback type used by commit-y operations to get a commit log message
   from the caller.
   
   COMMIT_ITEMS is an array of svn_client_commit_item_t structures,
   which may be fully or only partially filled-in, depending on the
   type of commit operation.  The callback handler should populate
   *LOG_MSG with the log message of the commit, or NULL if it wishes
   to abort the commit process.

   BATON is provided along with the callback for use by the handler.

   All allocations should be performed in POOL.  */
typedef svn_error_t *
(*svn_client_get_commit_log_t) (svn_stringbuf_t **log_msg,
                                apr_array_header_t *commit_items,
                                void *baton,
                                apr_pool_t *pool);


/* Names of files that contain authentication information.

   These filenames are decided by libsvn_client, since this library
   implements all the auth-protocols;  libsvn_wc does nothing but
   blindly store and retrieve these files from protected areas. */
#define SVN_CLIENT_AUTH_USERNAME            "username"
#define SVN_CLIENT_AUTH_PASSWORD            "password"


/*** Milestone 4 Interfaces ***/

/* Checkout a working copy of URL at REVISION, using PATH as the root
   directory of the newly checked out working copy, and authenticating
   with AUTH_BATON.

   REVISION must be of kind svn_client_revision_number,
   svn_client_revision_head, or svn_client_revision_date.  In the xml
   case (see below) svn_client_revision_unspecified is also allowed.
   If REVISION does not meet these requirements, return the error
   SVN_ERR_CLIENT_BAD_REVISION.

   BEFORE_EDITOR, BEFORE_EDIT_BATON and AFTER_EDITOR, AFTER_EDIT_BATON
   are pre- and post-checkout hook editors.  They are optional; pass
   four NULLs if you don't need them.

   If XML_SRC is non-NULL, it is an xml file to check out from; in
   this case, the working copy will record the URL as artificial
   ancestry information.  If REVISION is
   svn_client_revision_unspecified, then the revision *must* be
   present in the <delta-pkg> tag; otherwise, store REVISION in the
   wc. (Note: a <delta-pkg> revision still overrides REVISION.)

   Use POOL for any temporary allocation. */
svn_error_t *
svn_client_checkout (const svn_delta_editor_t *before_editor,
                     void *before_edit_baton,
                     const svn_delta_editor_t *after_editor,
                     void *after_edit_baton,
                     svn_client_auth_baton_t *auth_baton,
                     svn_stringbuf_t *URL,
                     svn_stringbuf_t *path,
                     const svn_client_revision_t *revision,
                     svn_boolean_t recurse,
                     svn_stringbuf_t *xml_src,
                     apr_pool_t *pool);


/* Update working tree PATH to REVISION, authenticating with
   AUTH_BATON.

   REVISION must be of kind svn_client_revision_number,
   svn_client_revision_head, or svn_client_revision_date.  In the xml
   case (see below) svn_client_revision_unspecified is also allowed.
   If REVISION does not meet these requirements, return the error
   SVN_ERR_CLIENT_BAD_REVISION.

   During an update, files may be restored from the text-base if they
   have been removed from the working copy.  When this happens,
   NOTIFY_FUNC will be called with NOTIFY_BATON and the (relative)
   path of the file that has been restored.  NOTIFY_FUNC may be
   NULL if this information is not required.

   BEFORE_EDITOR, BEFORE_EDIT_BATON and AFTER_EDITOR, AFTER_EDIT_BATON
   are pre- and post-update hook editors.  They are optional; pass
   four NULLs if you don't need them.

   If XML_SRC is non-NULL, it is an xml file to update from.  If
   REVISION is svn_client_revision_unspecified, then the revision
   *must* be present in the <delta-pkg> tag; otherwise, store REVISION
   in the wc. (Note: a <delta-pkg> revision still overrides REVISION.)
   
   Use POOL for any temporary allocation. */
svn_error_t *
svn_client_update (const svn_delta_editor_t *before_editor,
                   void *before_edit_baton,
                   const svn_delta_editor_t *after_editor,
                   void *after_edit_baton,
                   svn_client_auth_baton_t *auth_baton,
                   svn_stringbuf_t *path,
                   svn_stringbuf_t *xml_src,
                   const svn_client_revision_t *revision,
                   svn_boolean_t recurse,
                   svn_wc_notify_func_t notify_func,
                   void *notify_baton,
                   apr_pool_t *pool);


/* Switch working tree PATH to URL at REVISION, authenticating with
   AUTH_BATON.

   Summary of purpose: this is normally used to switch a working
   directory over to another line of development, such as a branch or
   a tag.  Switching an existing working directory is more efficient
   than checking out URL from scratch.

   REVISION must be of kind svn_client_revision_number,
   svn_client_revision_head, or svn_client_revision_date; otherwise,
   return SVN_ERR_CLIENT_BAD_REVISION.

   During a switch, files may be restored from the text-base if they
   have been removed from the working copy. When this happens,
   NOTIFY_FUNC will be called with NOTIFY_BATON and the (relative)
   path of the file that has been restored. NOTIFY_FUNC may be NULL
   if this information is not required.

   BEFORE_EDITOR, BEFORE_EDIT_BATON and AFTER_EDITOR, AFTER_EDIT_BATON
   are pre- and post-switch hook editors.  They are optional; pass
   four NULLs if you don't need them.

   Use POOL for any temporary allocation. */
svn_error_t *
svn_client_switch (const svn_delta_editor_t *before_editor,
                   void *before_edit_baton,
                   const svn_delta_editor_t *after_editor,
                   void *after_edit_baton,
                   svn_client_auth_baton_t *auth_baton,
                   svn_stringbuf_t *path,
                   svn_stringbuf_t *url,
                   const svn_client_revision_t *revision,
                   svn_boolean_t recurse,
                   svn_wc_notify_func_t notify_func,
                   void *notify_baton,
                   apr_pool_t *pool);


/* Schedule a working copy PATH for addition to the repository.
   PATH's parent must be under revision control already, but PATH is
   not.  If RECURSIVE is set, then assuming PATH is a directory, all
   of its contents will be scheduled for addition as well.

   For each item which is added, NOTIFY_FUNC will be called with
   NOTIFY_BATON and the path of the added item. NOTIFY_FUNC may be
   NULL if this information is not required.

   Important:  this is a *scheduling* operation.  No changes will
   happen to the repository until a commit occurs.  This scheduling
   can be removed with svn_client_revert. */
svn_error_t *
svn_client_add (svn_stringbuf_t *path,
                svn_boolean_t recursive,
                svn_wc_notify_func_t notify_func,
                void *notify_baton,
                apr_pool_t *pool);

/* If PATH is a URL, use the AUTH_BATON and MESSAGE to immediately
   attempt to commit the creation of the directory URL in the
   repository.  If the commit succeeds, allocate (in POOL) and
   populate *COMMIT_INFO.

   Else, create the directory on disk, and attempt to schedule it for
   addition (using svn_client_add, whose docstring you should
   read).

   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   When the directory has been created (successfully) in the working
   copy, NOTIFY_FUNC will be called with NOTIFY_BATON and the path of
   the new directory.  If this information is not required, then
   NOTIFY_FUNC may be NULL. Note that this is only called for items
   added to the working copy.
*/
svn_error_t *
svn_client_mkdir (svn_client_commit_info_t **commit_info,
                  svn_stringbuf_t *path,
                  svn_client_auth_baton_t *auth_baton,
                  svn_client_get_commit_log_t log_msg_func,
                  void *log_msg_baton,
                  svn_wc_notify_func_t notify_func,
                  void *notify_baton,
                  apr_pool_t *pool);
                  

/* If PATH is a URL, use the AUTH_BATON and MESSAGE to immediately
   attempt to commit a deletion of the URL from the repository.  If
   the commit succeeds, allocate (in POOL) and populate *COMMIT_INFO.
  
   Else, schedule a working copy PATH for removal from the repository.
   PATH's parent must be under revision control.  If FORCE is set,
   then PATH itself will be recursively removed as well; otherwise
   PATH simply stops being tracked by the working copy.  This is just
   a *scheduling* operation.  No changes will happen to the repository
   until a commit occurs.  This scheduling can be removed with
   svn_client_revert.

   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   For each item deleted, NOTIFY_FUNC will be called with NOTIFY_BATON
   and the path of the deleted item. NOTIFY_FUNC may be NULL if this
   information is not required.  */
svn_error_t *
svn_client_delete (svn_client_commit_info_t **commit_info,
                   svn_stringbuf_t *path,
                   svn_boolean_t force,
                   svn_client_auth_baton_t *auth_baton,
                   svn_client_get_commit_log_t log_msg_func,
                   void *log_msg_baton,
                   svn_wc_notify_func_t notify_func,
                   void *notify_baton,
                   apr_pool_t *pool);


/* Import file or directory PATH into repository directory URL at
   head, authenticating with AUTH_BATON, and using LOG_MSG as the log
   message for the (implied) commit.  Set *COMMIT_INFO to the results
   of the commit, allocated in POOL.
  
   NEW_ENTRY is the new entry created in the repository directory
   identified by URL.  NEW_ENTRY may be null (see below), but may not
   be the empty string.
  
   If PATH is a directory, the contents of that directory are
   imported, under a new directory named NEW_ENTRY under URL; or if
   NEW_ENTRY is null, then the contents of PATH are imported directly
   into the directory identified by URL.  Note that the directory PATH
   itself is not imported -- that is, the basename of PATH is not part
   of the import.

   If PATH is a file, that file is imported as NEW_ENTRY (which may
   not be null).

   In all cases, if NEW_ENTRY already exists in URL, return error.
   
   BEFORE_EDITOR, BEFORE_EDIT_BATON, and AFTER_EDITOR,
   AFTER_EDIT_BATON are pre- and post-import (i.e., post-commit) hook
   editors.  They are optional; pass four NULLs here if you don't need
   them.

   If XML_DST is non-NULL, it is a file in which to store the xml
   result of the commit, and REVISION is used as the revision.
   
   Use POOL for any temporary allocation.  
   
   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   Note: REVISION is svn_revnum_t, rather than svn_client_revision_t,
   because only the svn_client_revision_number kind would be useful
   anyway.

   ### kff todo: This import is similar to cvs import, in that it does
   not change the source tree into a working copy.  However, this
   behavior confuses most people, and I think eventually svn _should_
   turn the tree into a working copy, or at least should offer the
   option. However, doing so is a bit involved, and we don't need it
   right now.  
*/
svn_error_t *svn_client_import (svn_client_commit_info_t **commit_info,
                                const svn_delta_editor_t *before_editor,
                                void *before_edit_baton,
                                const svn_delta_editor_t *after_editor,
                                void *after_edit_baton, 
                                svn_client_auth_baton_t *auth_baton,   
                                svn_stringbuf_t *path,
                                svn_stringbuf_t *url,
                                svn_stringbuf_t *new_entry,
                                svn_client_get_commit_log_t log_msg_func,
                                void *log_msg_baton,
                                svn_stringbuf_t *xml_dst,
                                svn_revnum_t revision,
                                apr_pool_t *pool);


/* Commit file or directory PATH into repository, authenticating with
   AUTH_BATON, and using LOG_MSG as the log message.  Set *COMMIT_INFO
   to the results of the commit, allocated in POOL.

   TARGETS is an array of svn_stringbuf_t * paths to commit.  They need
   not be canonicalized nor condensed; this function will take care of
   that.

   BEFORE_EDITOR, BEFORE_EDIT_BATON, and AFTER_EDITOR,
   AFTER_EDIT_BATON are pre- and post-commit hook editors.  They are
   optional; pass four NULLs here if you don't need them.

   Additionally, NOTIFY_FUNC/BATON will be called as the commit
   progresses, as a way of describing actions to the application
   layer.

   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   If XML_DST is NULL, then the commit will write to a repository, and
   the REVISION argument is ignored.

   If XML_DST is non-NULL, it is a file path to commit to.  In this
   case, if REVISION is valid, the working copy's revision numbers
   will be updated appropriately.  If REVISION is invalid, the working
   copy remains unchanged.

   Note: REVISION is svn_revnum_t, rather than svn_client_revision_t,
   because only the svn_client_revision_number kind would be useful
   anyway.

   Use POOL for any temporary allocation.

   If no error is returned and (*COMMIT_INFO)->revision is set to
   SVN_INVALID_REVNUM, then the commit was a no-op; nothing needed to
   be committed.
 */
svn_error_t *
svn_client_commit (svn_client_commit_info_t **commit_info,
                   const svn_delta_editor_t *before_editor,
                   void *before_edit_baton,
                   const svn_delta_editor_t *after_editor,
                   void *after_edit_baton,
                   svn_wc_notify_func_t notify_func,
                   void *notify_baton,
                   svn_client_auth_baton_t *auth_baton,
                   const apr_array_header_t *targets,
                   svn_client_get_commit_log_t log_msg_func,
                   void *log_msg_baton,
                   svn_stringbuf_t *xml_dst,
                   svn_revnum_t revision,
                   apr_pool_t *pool);


/* Given PATH to a working copy directory (or single file), allocate
   and return a hash STATUSHASH which maps (char *) paths to
   (svn_wc_status_t *) structures.

   This is a purely local operation; only information found in the
   administrative `entries' files is used to initially build the
   structures.

      - If DESCEND is non-zero, recurse fully, else do only immediate
        children.  This (inversely) corresponds to the "-n"
        (--nonrecursive) flag in the commandline client app.

      - If GET_ALL is set, then all entries are retrieved; otherwise
        only "interesting" entries (local mods and/or out-of-date)
        will be fetched.  This directly corresponds to the "-v"
        (--verbose) flag in the commandline client app.

      - If UPDATE is set, then the repository will be contacted, so
        that the structures in STATUSHASH are augmented with
        information about out-of-dateness, and *YOUNGEST is set to the
        youngest repository revision (*YOUNGEST is not touched unless
        UPDATE is set).  This directly corresponds to the "-u"
        (--show-updates) flag in the commandline client app.

  */
svn_error_t *
svn_client_status (apr_hash_t **statushash,
                   svn_revnum_t *youngest,  /* only touched if `update' set */
                   svn_stringbuf_t *path,
                   svn_client_auth_baton_t *auth_baton,
                   svn_boolean_t descend,
                   svn_boolean_t get_all,
                   svn_boolean_t update,
                   apr_pool_t *pool);


/* Invoke RECEIVER with RECEIVER_BATON on each log message from START
   to END in turn, inclusive (but never invoke RECEIVER on a given log
   message more than once).
  
   TARGETS contains all the working copy paths (as svn_stringbuf_t *'s)
   for which log messages are desired; the common prefix of TARGETS
   determines the repository and auth info.  RECEIVER is invoked only
   on messages whose revisions involved a change to some path in
   TARGETS.
  
   ### todo: the above paragraph is not fully implemented yet.
  
   If DISCOVER_CHANGED_PATHS is set, then the `changed_paths' argument
   to RECEIVER will be passed on each invocation.
  
   If START->kind or END->kind is svn_revision_unspecified_kind,
   return the error SVN_ERR_CLIENT_BAD_REVISION.

   Use POOL for any temporary allocation.
 */
svn_error_t *
svn_client_log (svn_client_auth_baton_t *auth_baton,
                const apr_array_header_t *targets,
                const svn_client_revision_t *start,
                const svn_client_revision_t *end,
                svn_boolean_t discover_changed_paths,
                svn_log_message_receiver_t receiver,
                void *receiver_baton,
                apr_pool_t *pool);


/* Produce diff output which describes the delta between
   PATH1/REVISION1 and PATH2/REVISION2.  Print the output of the diff
   to OUTFILE, and any errors to ERRFILE.

   PATH1 and PATH2 must both represent the same node kind -- that is,
   if PATH1 is a directory, PATH2 must also be, and if PATH1 is a
   file, PATH2 must also be.  (Currently, PATH1 and PATH2 must be the
   exact same path)

   If either REVISION1 or REVISION2 has an `unspecified' or
   unrecognized `kind', return SVN_ERR_CLIENT_BAD_REVISION.
  
   If RECURSE is true (and the PATHs are directories) this will be a
   recursive operation.
  
   DIFF_OPTIONS (an array of svn_stringbuf_t * items) is used to pass
   additional command line options to the diff processes invoked to
   compare files.
  
   AUTH_BATON is used to communicate with the repository.  */
svn_error_t *svn_client_diff (const apr_array_header_t *diff_options,
                              svn_client_auth_baton_t *auth_baton,
                              svn_stringbuf_t *path1,
                              const svn_client_revision_t *revision1,
                              svn_stringbuf_t *path2,
                              const svn_client_revision_t *revision2,
                              svn_boolean_t recurse,
                              apr_file_t *outfile,
                              apr_file_t *errfile,
                              apr_pool_t *pool);


/* Merge changes from PATH1/REVISION1 to PATH2/REVISION2 into the
   working-copy path TARGET_WCPATH.  PATH1 and PATH2 can be either
   working-copy paths or URLs.

   By "merging", we mean:  apply file differences using
   svn_wc_merge(), and schedule additions & deletions when appopriate.

   PATH1 and PATH2 must both represent the same node kind -- that is,
   if PATH1 is a directory, PATH2 must also be, and if PATH1 is a
   file, PATH2 must also be.  (Currently, PATH1 and PATH2 must be the
   exact same path.  ### Also true for merge, initially?)

   If either REVISION1 or REVlISION2 has an `unspecified' or
   unrecognized `kind', return SVN_ERR_CLIENT_BAD_REVISION.
  
   If RECURSE is true (and the PATHs are directories), apply changes
   recursively; otherwise, only apply changes in the current
   directory.
  
   AFTER_EDITOR/BATON are optional.  If non-NULL, they represent some
   sort of "trace" editor to be used during the merging.

   AUTH_BATON is used to communicate with the repository.  */
svn_error_t *
svn_client_merge (const svn_delta_editor_t *after_editor,
                  void *after_edit_baton,
                  svn_client_auth_baton_t *auth_baton,
                  svn_stringbuf_t *path1,
                  const svn_client_revision_t *revision1,
                  svn_stringbuf_t *path2,
                  const svn_client_revision_t *revision2,
                  svn_stringbuf_t *target_wcpath,
                  svn_boolean_t recurse,
                  apr_pool_t *pool);


/* Recursively cleanup a working copy directory DIR, finishing any
   incomplete operations, removing lockfiles, etc. */
svn_error_t *
svn_client_cleanup (svn_stringbuf_t *dir,
                    apr_pool_t *pool);


/* Restore the pristine version of a working copy PATH, effectively
   undoing any local mods.  If PATH is a directory, and RECURSIVE is
   TRUE, this will be a recursive operation.

   For each item reverted, NOTIFY_FUNC will be called with NOTIFY_BATON
   and the path of the reverted item. If this information is not required,
   then NOTIFY_FUNC may be NULL.  */
svn_error_t *
svn_client_revert (svn_stringbuf_t *path,
                   svn_boolean_t recursive,
                   svn_wc_notify_func_t notify_func,
                   void *notify_baton,
                   apr_pool_t *pool);


/* Remove the 'conflicted' state on a working copy PATH.  This will
   not semantically resolve conflicts;  it just allows PATH to be
   committed in the future.  The implementation details are opaque.

   If PATH is not in a state of conflict to begin with, do nothing.
   If PATH's conflict state is removed, call NOTIFY_FUNC (with
   NOTIFY_BATON) if the func is non-NULL. */
svn_error_t *
svn_client_resolve (svn_stringbuf_t *path,
                    svn_wc_notify_func_t notify_func,
                    void *notify_baton,
                    apr_pool_t *pool);


/* Copy SRC_PATH to DST_PATH.

   SRC_PATH must be a file or directory under version control, or the
   URL of a versioned item in the repository.  If SRC_PATH is a URL,
   SRC_REVISION is used to choose the revision from which to copy the
   SRC_PATH.  DST_PATH must be a file or directory under version
   control, or a repository URL, existent or not.

   If either SRC_PATH or DST_PATH are URLs, use the AUTH_BATON and
   MESSAGE to immediately attempt to commit the copy action in the
   repository.  If the commit succeeds, allocate (in POOL) and
   populate *COMMIT_INFO.

   If the operation involves interaction between the working copy and
   the repository, there may be an editor drive, in which case the
   BEFORE_EDITOR, BEFORE_EDIT_BATON and AFTER_EDITOR, AFTER_EDIT_BATON
   will be wrapped around the edit using svn_delta_wrap_editor()
   (which see in svn_delta.h).

   If neither SRC_PATH nor DST_PATH is a URL, then this is just a
   variant of svn_client_add, where the DST_PATH items are scheduled
   for addition as copies.  No changes will happen to the repository
   until a commit occurs.  This scheduling can be removed with
   svn_client_revert.

   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   For each item added (at the new location), NOTIFY_FUNC will be
   called with the NOTIFY_BATON and the (new, relative) path of the
   added item. If this information is not required, then NOTIFY_FUNC
   may be NULL.  */
svn_error_t *
svn_client_copy (svn_client_commit_info_t **commit_info,
                 svn_stringbuf_t *src_path,
                 const svn_client_revision_t *src_revision,
                 svn_stringbuf_t *dst_path,
                 svn_client_auth_baton_t *auth_baton,
                 svn_client_get_commit_log_t log_msg_func,
                 void *log_msg_baton,
                 const svn_delta_editor_t *before_editor,
                 void *before_edit_baton,
                 const svn_delta_editor_t *after_editor,
                 void *after_edit_baton,
                 svn_wc_notify_func_t notify_func,
                 void *notify_baton,
                 apr_pool_t *pool);


/* Move SRC_PATH to DST_PATH.

   SRC_PATH must be a file or directory under version control, or the
   URL of a versioned item in the repository.  

   If SRC_PATH is a repository URL:

     - DST_PATH must also be a repository URL (existent or not).

     - SRC_REVISION is used to choose the revision from which to copy the
       SRC_PATH.

     - AUTH_BATON and MESSAGE are used to commit the move.

     - The move operation will be immediately committed.  If the
       commit succeeds, allocate (in POOL) and populate *COMMIT_INFO.

   If SRC_PATH is a working copy path

     - DST_PATH must also be a working copy path (existent or not).

     - SRC_REVISION, AUTH and MESSAGE are ignored.

     - This is a scheduling operation.  No changes will happen to the
       repository until a commit occurs.  This scheduling can be
       removed with svn_client_revert.

   LOG_MSG_FUNC/LOG_MSG_BATON are a callback/baton combo that this
   function can use to query for a commit log message when one is
   needed.

   For each item moved, NOTIFY_FUNC will be called with the
   NOTIFY_BATON twice, once to indicate the deletion of the moved
   thing, and once to indicate the addition of the new location of the
   thing.  NOTIFY_FUNC can be NULL if this feedback is not required.  */
svn_error_t *
svn_client_move (svn_client_commit_info_t **commit_info,
                 svn_stringbuf_t *src_path,
                 const svn_client_revision_t *src_revision,
                 svn_stringbuf_t *dst_path,
                 svn_client_auth_baton_t *auth_baton,
                 svn_client_get_commit_log_t log_msg_func,
                 void *log_msg_baton,
                 svn_wc_notify_func_t notify_func,
                 void *notify_baton,
                 apr_pool_t *pool);


/* Set PROPNAME to PROPVAL on TARGET.  If RECURSE is true, then PROPNAME
   will be set on recursively on TARGET and all children.  If RECURSE is false,
   and TARGET is a directory, PROPNAME will be set on _only_ TARGET.
 
   Use POOL for all memory allocation. */
svn_error_t *
svn_client_propset (const char *propname,
                    const svn_string_t *propval,
                    const char *target,
                    svn_boolean_t recurse,
                    apr_pool_t *pool);

/* Set *PROPS to a hash table whose keys are `char *' paths,
   prefixed by TARGET, of items in the working copy on which 
   property PROPNAME is set, and whose values are `svn_string_t *'
   representing the property value for PROPNAME at that path.
   Allocate *PROPS, its keys, and its values in POOL.
             
   Don't store any path, not even TARGET, if it does not have a
   property named PROPNAME.

   If TARGET is a file or RECURSE is false, *PROPS will have
   at most one element.

   If error, don't touch *PROPS, otherwise *PROPS is a hash table even if
   empty. */
svn_error_t *
svn_client_propget (apr_hash_t **props,
                    const char *propname,
                    const char *target,
                    svn_boolean_t recurse,
                    apr_pool_t *pool);

/* Returns an apr_array_header_t of svn_client_proplist_item_t's in *PROPS,
   allocated from POOL. Each item will contain the node_name relative to the
   same base as target in item->node_name, and a property hash of 
   (const char *) property names, and (svn_stringbuf_t *) property values.

   If recurse is false, or TARGET is a file, *PROPS will contain only a single
   element.  Otherwise, it will contain one for each versioned entry below
   (and including) TARGET. */
svn_error_t *
svn_client_proplist (apr_array_header_t **props,
                     const char *target, 
                     svn_boolean_t recurse,
                     apr_pool_t *pool);


/* Cancellation. */

/* A function type for determining whether or not to cancel an operation.
 * Returns TRUE if should cancel, FALSE if should not.
 */
typedef svn_boolean_t (*svn_client_cancellation_func_t) (void *baton);


/* Set *EDITOR and *EDIT_BATON to an editor that returns
 * SVN_ERR_CANCELED if SHOULD_I_CANCEL(CANCEL_BATON) ever returns
 * true.  Should be composed before any editor that does any real
 * work.
 */
svn_error_t *svn_client_get_cancellation_editor
      (const svn_delta_edit_fns_t **editor,
       void **edit_baton,
       svn_client_cancellation_func_t should_i_cancel,
       void *cancel_baton,
       apr_pool_t *pool);


#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif  /* SVN_CLIENT_H */


/* --------------------------------------------------------------
 * local variables:
 * eval: (load-file "../../tools/dev/svn-dev.el")
 * end: 
 */