view release on metacpan or  search on metacpan

src/subversion/subversion/libsvn_fs_fs/dag.h  view on Meta::CPAN

                                          svn_fs_t *fs,
                                          svn_revnum_t rev,
                                          apr_pool_t *pool);


/* Set *NODE_P to the root of transaction TXN_ID in FS, allocating
   from POOL.

   Note that the root node of TXN_ID is not necessarily mutable.  If
   no changes have been made in the transaction, then it may share its
   root directory with its base revision.  To get a mutable root node
   for a transaction, call svn_fs_fs__dag_clone_root.  */
svn_error_t *svn_fs_fs__dag_txn_root(dag_node_t **node_p,
                                     svn_fs_t *fs,
                                     const char *txn_id,
                                     apr_pool_t *pool);


/* Set *NODE_P to the base root of transaction TXN_ID in FS,
   allocating from POOL.  Allocate the node in TRAIL->pool.  */
svn_error_t *svn_fs_fs__dag_txn_base_root(dag_node_t **node_p,
                                          svn_fs_t *fs,
                                          const char *txn_id,
                                          apr_pool_t *pool);


/* Clone the root directory of TXN_ID in FS, and update the
   `transactions' table entry to point to it, unless this has been
   done already.  In either case, set *ROOT_P to a reference to the
   root directory clone.  Allocate *ROOT_P in POOL.  */
svn_error_t *svn_fs_fs__dag_clone_root(dag_node_t **root_p,
                                       svn_fs_t *fs,
                                       const char *txn_id,
                                       apr_pool_t *pool);



/* Directories.  */


/* Open the node named NAME in the directory PARENT.  Set *CHILD_P to
   the new node, allocated in RESULT_POOL.  NAME must be a single path
   component; it cannot be a slash-separated directory path.
 */
svn_error_t *
svn_fs_fs__dag_open(dag_node_t **child_p,
                    dag_node_t *parent,
                    const char *name,
                    apr_pool_t *result_pool,
                    apr_pool_t *scratch_pool);


/* Set *ENTRIES_P to a hash table of NODE's entries.  The keys of the
   table are entry names, and the values are svn_fs_dirent_t's.  The
   returned table (and its keys and values) is allocated in POOL,
   which is also used for temporary allocations. */
svn_error_t *svn_fs_fs__dag_dir_entries(apr_hash_t **entries_p,
                                        dag_node_t *node,
                                        apr_pool_t *pool);

/* Fetches the NODE's entries and returns a copy of the entry selected
   by the key value given in NAME and set *DIRENT to a copy of that
   entry. If such entry was found, the copy will be allocated in POOL.
   Otherwise, the *DIRENT will be set to NULL.
 */
/* ### This function is currently only called from dag.c. */
svn_error_t * svn_fs_fs__dag_dir_entry(svn_fs_dirent_t **dirent,
                                       dag_node_t *node,
                                       const char* name,
                                       apr_pool_t *pool);

/* Set ENTRY_NAME in NODE to point to ID (with kind KIND), allocating
   from POOL.  NODE must be a mutable directory.  ID can refer to a
   mutable or immutable node.  If ENTRY_NAME does not exist, it will
   be created.  TXN_ID is the Subversion transaction under which this
   occurs.

   Use POOL for all allocations, including to cache the node_revision in
   NODE.
 */
svn_error_t *svn_fs_fs__dag_set_entry(dag_node_t *node,
                                      const char *entry_name,
                                      const svn_fs_id_t *id,
                                      svn_node_kind_t kind,
                                      const char *txn_id,
                                      apr_pool_t *pool);


/* Make a new mutable clone of the node named NAME in PARENT, and
   adjust PARENT's directory entry to point to it, unless NAME in
   PARENT already refers to a mutable node.  In either case, set
   *CHILD_P to a reference to the new node, allocated in POOL.  PARENT
   must be mutable.  NAME must be a single path component; it cannot
   be a slash-separated directory path.  PARENT_PATH must be the
   canonicalized absolute path of the parent directory.

   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.

   PATH is the canonicalized absolute path at which this node is being
   created.

   TXN_ID is the Subversion transaction under which this occurs.

   Use POOL for all allocations.
 */
svn_error_t *svn_fs_fs__dag_clone_child(dag_node_t **child_p,
                                        dag_node_t *parent,
                                        const char *parent_path,
                                        const char *name,
                                        const char *copy_id,
                                        const char *txn_id,
                                        svn_boolean_t is_parent_copyroot,
                                        apr_pool_t *pool);


/* Delete the directory entry named NAME from PARENT, allocating from
   POOL.  PARENT must be mutable.  NAME must be a single path
   component; it cannot be a slash-separated directory path.  If the
   node being deleted is a mutable directory, remove all mutable nodes