fs_fs.h

来自「subversion-1.4.5.tar.gz 配置svn的源码」· C头文件 代码 · 共 421 行 · 第 1/2 页

   from POOL. */
svn_error_t *svn_fs_fs__add_change(svn_fs_t *fs,
                                   const char *txn_id,
                                   const char *path,
                                   const svn_fs_id_t *id,
                                   svn_fs_path_change_kind_t change_kind,
                                   svn_boolean_t text_mod,
                                   svn_boolean_t prop_mod,
                                   svn_revnum_t copyfrom_rev,
                                   const char *copyfrom_path,
                                   apr_pool_t *pool);

/* Return a writable stream in *STREAM that allows storing the text
   representation of node-revision NODEREV in filesystem FS.
   Allocations are from POOL. */
svn_error_t *svn_fs_fs__set_contents(svn_stream_t **stream,
                                     svn_fs_t *fs,
                                     node_revision_t *noderev,
                                     apr_pool_t *pool);

/* Create a node revision in FS which is an immediate successor of
   OLD_ID, whose contents are NEW_NR.  Set *NEW_ID_P to the new node
   revision's ID.  Use POOL for any temporary allocation.

   COPY_ID, if non-NULL, is a key into the `copies' table, and
   indicates that this new node is being created as the result of a
   copy operation, and specifically which operation that was.  If
   COPY_ID is NULL, then re-use the copy ID from the predecessor node.

   TXN_ID is the Subversion transaction under which this occurs.

   After this call, the deltification code assumes that the new node's
   contents will change frequently, and will avoid representing other
   nodes as deltas against this node's contents.  */
svn_error_t *svn_fs_fs__create_successor(const svn_fs_id_t **new_id_p,
                                         svn_fs_t *fs,
                                         const svn_fs_id_t *old_idp,
                                         node_revision_t *new_noderev,
                                         const char *copy_id,
                                         const char *txn_id,
                                         apr_pool_t *pool);

/* Write a new property list PROPLIST for node-revision NODEREV in
   filesystem FS.  Perform any temporary allocations in POOL. */
svn_error_t *svn_fs_fs__set_proplist(svn_fs_t *fs,
                                     node_revision_t *noderev,
                                     apr_hash_t *proplist,
                                     apr_pool_t *pool);

/* Commit the transaction TXN in filesystem FS and return its new
   revision number in *REV.  If the transaction is out of date, return
   the error SVN_ERR_FS_TXN_OUT_OF_DATE.  Use POOL for temporary
   allocations. */
svn_error_t *svn_fs_fs__commit(svn_revnum_t *new_rev_p,
                               svn_fs_t *fs,
                               svn_fs_txn_t *txn,
                               apr_pool_t *pool);

/* Return the next available copy_id in *COPY_ID for the transaction
   TXN_ID in filesystem FS.  Allocate space in POOL. */
svn_error_t *svn_fs_fs__reserve_copy_id(const char **copy_id,
                                        svn_fs_t *fs,
                                        const char *txn_id,
                                        apr_pool_t *pool);

/* Create a fs_fs fileysystem referenced by FS at path PATH.  Get any
   temporary allocations from POOL. */
svn_error_t *svn_fs_fs__create(svn_fs_t *fs,
                               const char *path,
                               apr_pool_t *pool);

/* Store the uuid of the repository FS in *UUID.  Allocate space in
   POOL. */
svn_error_t *svn_fs_fs__get_uuid(svn_fs_t *fs,
                                 const char **uuid,
                                 apr_pool_t *pool);

/* Set the uuid of repository FS to UUID.  Perform temporary
   allocations in POOL. */
svn_error_t *svn_fs_fs__set_uuid(svn_fs_t *fs,
                                 const char *uuid,
                                 apr_pool_t *pool);

/* Set *NAMES_P to an array of names which are all the active
   transactions in filesystem FS.  Allocate the array from POOL. */
svn_error_t *svn_fs_fs__list_transactions(apr_array_header_t **names_p,
                                          svn_fs_t *fs,
                                          apr_pool_t *pool);

/* Open the transaction named NAME in filesystem FS.  Set *TXN_P to
 * the transaction. If there is no such transaction, return
` * SVN_ERR_FS_NO_SUCH_TRANSACTION.  Allocate the new transaction in
 * POOL. */
svn_error_t *svn_fs_fs__open_txn(svn_fs_txn_t **txn_p,
                                 svn_fs_t *fs,
                                 const char *name,
                                 apr_pool_t *pool);

/* Return the property list from transaction TXN and store it in
   *PROPLIST.  Allocate the property list from POOL. */
svn_error_t *svn_fs_fs__txn_proplist(apr_hash_t **proplist,
                                     svn_fs_txn_t *txn,
                                     apr_pool_t *pool);

/* Delete the mutable node-revision referenced by ID, along with any
   mutable props or directory contents associated with it.  Perform
   temporary allocations in POOL. */
svn_error_t *svn_fs_fs__delete_node_revision(svn_fs_t *fs,
                                             const svn_fs_id_t *id,
                                             apr_pool_t *pool);


/* Find the paths which were changed in transaction TXN_ID of
   filesystem FS and store them in *CHANGED_PATHS_P.  Cached copyfrom
   information will be stored in COPYFROM_CACHE if it is non-NULL.
   Get any temporary allocations from POOL. */
svn_error_t *svn_fs_fs__txn_changes_fetch(apr_hash_t **changes,
                                          svn_fs_t *fs,
                                          const char *txn_id,
                                          apr_hash_t *copyfrom_cache,
                                          apr_pool_t *pool);


/* Move a file into place from OLD_FILENAME in the transactions
   directory to its final location NEW_FILENAME in the repository.  On
   Unix, match the permissions of the new file to the permissions of
   PERMS_REFERENCE.  Temporary allocations are from POOL. */
svn_error_t *svn_fs_fs__move_into_place(const char *old_filename, 
                                        const char *new_filename,
                                        const char *perms_reference, 
                                        apr_pool_t *pool);

/* Match the perms on FILENAME to the PERMS_REFERENCE file if we're
   not on a win32 system.  On win32, this is a no-op. */
svn_error_t *svn_fs_fs__dup_perms(const char *filename,
                                  const char *perms_reference,
                                  apr_pool_t *pool);

/* Return the path to the file containing revision REV in FS.
   Allocate the new char * from POOL. */
const char *svn_fs_fs__path_rev(svn_fs_t *fs, 
                                svn_revnum_t rev, 
                                apr_pool_t *pool);

/* Obtain a write lock on the filesystem FS in a subpool of POOL, call
   BODY with BATON and that subpool, destroy the subpool (releasing the write
   lock) and return what BODY returned. */
svn_error_t *
svn_fs_fs__with_write_lock(svn_fs_t *fs,
                           svn_error_t *(*body)(void *baton,
                                                apr_pool_t *pool),
                           void *baton,
                           apr_pool_t *pool);

/* Find the value of the property named PROPNAME in transaction TXN.
   Return the contents in *VALUE_P.  The contents will be allocated
   from POOL. */
svn_error_t *svn_fs_fs__revision_prop(svn_string_t **value_p, svn_fs_t *fs,
                                      svn_revnum_t rev,
                                      const char *propname,
                                      apr_pool_t *pool);

/* Change, add, or delete a property on a revision REV in filesystem
   FS.  NAME gives the name of the property, and value, if non-NULL,
   gives the new contents of the property.  If value is NULL, then the
   property will be deleted.  Do any temporary allocation in POOL.  */
svn_error_t *svn_fs_fs__change_rev_prop(svn_fs_t *fs, svn_revnum_t rev,
                                        const char *name,
                                        const svn_string_t *value,
                                        apr_pool_t *pool);

/* Retrieve information about the Subversion transaction SVN_TXN from
   the `transactions' table of FS, allocating from POOL.  Set
   *ROOT_ID_P to the ID of the transaction's root directory.  Set
   *BASE_ROOT_ID_P to the ID of the root directory of the
   transaction's base revision.

   If there is no such transaction, SVN_ERR_FS_NO_SUCH_TRANSACTION is
   the error returned.

   Returns SVN_ERR_FS_TRANSACTION_NOT_MUTABLE if TXN_NAME refers to a
   transaction that has already been committed.

   Allocate *ROOT_ID_P and *BASE_ROOT_ID_P in POOL.  */
svn_error_t *svn_fs_fs__get_txn_ids(const svn_fs_id_t **root_id_p,
                                    const svn_fs_id_t **base_root_id_p,
                                    svn_fs_t *fs,
                                    const char *txn_name,
                                    apr_pool_t *pool);

/* Begin a new transaction in filesystem FS, based on existing
   revision REV.  The new transaction is returned in *TXN_P.  Allocate
   the new transaction structure from POOL. */
svn_error_t *svn_fs_fs__begin_txn(svn_fs_txn_t **txn_p, svn_fs_t *fs,
                                  svn_revnum_t rev, apr_uint32_t flags,
                                  apr_pool_t *pool);

/* Abort the existing transaction TXN, performing any temporary
   allocations in POOL. */
svn_error_t *svn_fs_fs__abort_txn(svn_fs_txn_t *txn, apr_pool_t *pool);

/* Find the value of the property named PROPNAME in transaction TXN.
   Return the contents in *VALUE_P.  The contents will be allocated
   from POOL. */
svn_error_t *svn_fs_fs__txn_prop(svn_string_t **value_p, svn_fs_txn_t *txn,
                                 const char *propname, apr_pool_t *pool);


#endif