subversion/libsvn_fs/this-branch.txt

These are all the functions in the public svn_fs.h interface that will
lead to code affected by the strings/reps changes:

svn_fs_node_id                (svn_fs_id_t **id_p, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_node_prop              (svn_stringbuf_t **value_p, svn_fs_root_t *root, const char *path, const svn_string_t *propname, apr_pool_t *pool);
svn_fs_node_proplist          (apr_hash_t **table_p, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_change_node_prop       (svn_fs_root_t *root, const char *path, const svn_string_t *name, const svn_string_t *value, apr_pool_t *pool);
svn_fs_merge                  (const char **conflict_p, svn_fs_root_t *source_root, const char *source_path, svn_fs_root_t *target_root, const char *target_path, svn_fs_root_t *ancestor_root, const char *ancestor_path, apr_pool_t *pool);
svn_fs_is_different           (int *is_different, svn_fs_root_t *root1, const char *path1, svn_fs_root_t *root2, const char *path2, apr_pool_t *pool);
svn_fs_dir_entries            (apr_hash_t **table_p, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_make_dir               (svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_delete                 (svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_delete_tree            (svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_rename                 (svn_fs_root_t *root, const char *from, const char *to, apr_pool_t *pool);
svn_fs_copy                   (svn_fs_root_t *from_root, const char *from_path, svn_fs_root_t *to_root, const char *to_path, apr_pool_t *pool);
svn_fs_file_length            (apr_off_t *length_p, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_file_contents          (svn_stream_t **contents, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_make_file              (svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_apply_textdelta        (svn_txdelta_window_handler_t *contents_p, void **contents_baton_p, svn_fs_root_t *root, const char *path, apr_pool_t *pool);
svn_fs_get_file_delta_stream  (svn_txdelta_stream_t **stream_p, svn_fs_root_t *source_root, const char *source_path, svn_fs_root_t *target_root, const char *target_path, apr_pool_t *pool);

And these are all the exported functions implemented in dag.c:

   DONE:
      svn_fs__dag_check_mutable
      svn_fs__dag_get_node
      svn_fs__dag_init_fs
      svn_fs__dag_dir_entries_skel
      svn_fs__dag_dir_entries_hash
      svn_fs__dag_is_file
      svn_fs__dag_is_directory
      svn_fs__dag_is_copy
      svn_fs__dag_get_id
      svn_fs__dag_get_fs
      svn_fs__dag_get_proplist
      svn_fs__dag_revision_root
      svn_fs__dag_txn_root
      svn_fs__dag_txn_base_root
      svn_fs__dag_clone_root
      svn_fs__dag_file_length
      svn_fs__dag_dup
      svn_fs__dag_open
      svn_fs__dag_make_copy (needs some ### tweakits, warnings, alarms...)
      svn_fs__dag_commit_txn
      svn_fs__dag_set_entry
      svn_fs__dag_clone_child
      svn_fs__dag_make_file
      svn_fs__dag_make_dir
      svn_fs__dag_link
      svn_fs__dag_delete
      svn_fs__dag_delete_tree
      svn_fs__dag_delete_if_mutable
      svn_fs__dag_get_contents
      svn_fs__dag_set_proplist
      svn_fs__dag_set_contents

      
-*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- -*- 


/* Set *ID_P to the node revision ID of PATH in ROOT, allocated in POOL.

   If ROOT is the root of a transaction, keep in mind that other
   changes to the transaction can change which node PATH refers to,
   and even whether the path exists at all.  */
svn_error_t *svn_fs_node_id (svn_fs_id_t **id_p,
                             svn_fs_root_t *root,
                             const char *path,
                             apr_pool_t *pool);


/* Set *VALUE_P to the value of the property named PROPNAME of PATH in
   ROOT.  If the node has no property by that name, set *VALUE_P to
   zero.  Allocate the result in POOL.  */
svn_error_t *svn_fs_node_prop (svn_stringbuf_t **value_p,
                               svn_fs_root_t *root,
                               const char *path,
                               const svn_string_t *propname,
                               apr_pool_t *pool);
   

/* Set *TABLE_P to the entire property list of PATH in ROOT, as an APR
   hash table allocated in POOL.  The resulting table maps property
   names to pointers to svn_string_t objects containing the property
   value.  */
svn_error_t *svn_fs_node_proplist (apr_hash_t **table_p,
                                   svn_fs_root_t *root,
                                   const char *path,
                                   apr_pool_t *pool);


/* Change a node's property's value, or add/delete a property.
   - ROOT and PATH indicate the node whose property should change.
     ROOT must be the root of a transaction, not the root of a revision.
   - NAME is the name of the property to change.
   - VALUE is the new value of the property, or zero if the property should
     be removed altogether.
   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_change_node_prop (svn_fs_root_t *root,
                                      const char *path,
                                      const svn_string_t *name,
                                      const svn_string_t *value,
                                      apr_pool_t *pool);


/* Given nodes SOURCE and TARGET, and a common ancestor ANCESTOR,
   modify TARGET to contain all the changes made between ANCESTOR and
   SOURCE, as well as the changes made between ANCESTOR and TARGET.
   TARGET_ROOT must be the root of a transaction, not a revision.

   SOURCE, TARGET, and ANCESTOR are generally directories; this
   function recursively merges the directories' contents.  If they are
   files, this function simply returns an error whenever SOURCE,
   TARGET, and ANCESTOR are all distinct node revisions.

   If there are differences between ANCESTOR and SOURCE that conflict
   with changes between ANCESTOR and TARGET, this function returns an
   SVN_ERR_FS_CONFLICT error.

   If the merge is successful, TARGET is left in the merged state, and
   the base root of TARGET's txn is set to the root node of SOURCE.
   If an error is returned (whether for conflict or otherwise), TARGET
   is left unaffected.

   If CONFLICT_P is non-null, then: a conflict error sets *CONFLICT_P
   to the name of the node in TARGET which couldn't be merged,
   otherwise, success sets *CONFLICT_P to null.

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_merge (const char **conflict_p,
                           svn_fs_root_t *source_root,
                           const char *source_path,
                           svn_fs_root_t *target_root,
                           const char *target_path,
                           svn_fs_root_t *ancestor_root,
                           const char *ancestor_path,
                           apr_pool_t *pool);



/* Compare the nodes ROOT1:PATH1 and ROOT2:PATH2, and determine if
   they are "different".  Return the answer in IS_DIFFERENT.

   We define two nodes to be "different" if:

       - they are different node types, or

       - if both files, they have different node-revision-ids, or 
 
       - if both dirs, they have different entry lists.

   (Note that there is a small chance of getting a false positive: two
   different node-rev-ids don't *necessarily* have different contents.
   But right now it's not worth doing byte-for-byte comparisons.  This
   problem will go away when we have deltified storage.) */
svn_error_t *svn_fs_is_different (int *is_different,
                                  svn_fs_root_t *root1,
                                  const char *path1,
                                  svn_fs_root_t *root2,
                                  const char *path2,
                                  apr_pool_t *pool);
                                  

/* Set *TABLE_P to a newly allocated APR hash table containing the
   entries of the directory at PATH in ROOT.  The keys of the table
   are entry names, as byte strings, excluding the final null
   character; the table's values are pointers to svn_fs_dirent_t
   structures.  Allocate the table and its contents in POOL.  */
svn_error_t *svn_fs_dir_entries (apr_hash_t **table_p,
                                 svn_fs_root_t *root,
                                 const char *path,
                                 apr_pool_t *pool);


/* Create a new directory named PATH in ROOT.  The new directory has
   no entries, and no properties.  ROOT must be the root of a
   transaction, not a revision.

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_make_dir (svn_fs_root_t *root,
                              const char *path,
                              apr_pool_t *pool);
                              

/* Delete the node named PATH in ROOT.  ROOT must be the root of a
   transaction, not a revision.  Do any necessary temporary allocation
   in POOL.

   If the node being deleted is a directory, it must be empty, else
   the error SVN_ERR_FS_DIR_NOT_EMPTY is returned.

   Attempting to remove the root dir also results in an error,
   SVN_ERR_FS_ROOT_DIR, even if the dir is empty.  */
svn_error_t *svn_fs_delete (svn_fs_root_t *root,
                            const char *path,
                            apr_pool_t *pool);


/* Delete the node named PATH in ROOT.  If the node being deleted is a
   directory, its contents will be deleted recursively.  ROOT must be
   the root of a transaction, not of a revision.

   This function may be more efficient than making the equivalent
   series of calls to svn_fs_delete, because it takes advantage of the
   fact that, to delete an immutable subtree, shared with some
   committed revision, you need only remove the directory entry.  The
   dumb algorithm would recurse into the subtree and end up cloning
   each non-empty directory it contains, only to delete it later.

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_delete_tree (svn_fs_root_t *root,
                                 const char *path,
                                 apr_pool_t *pool);


/* Move the node named FROM to TO, both in ROOT.  ROOT must be the
   root of a transaction, not a revision.

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_rename (svn_fs_root_t *root,
                            const char *from,
                            const char *to,
                            apr_pool_t *pool);


/* Create a copy of FROM_PATH in FROM_ROOT named TO_PATH in TO_ROOT.
   If FROM_PATH in FROM_ROOT is a directory, copy the tree it refers
   to recursively.

   TO_ROOT must be the root of a transaction; FROM_PATH must be the
   root of a revision.  (Requiring FROM_PATH to be the root of a
   revision makes the implementation trivial: there is no detectable
   difference (modulo node revision ID's) between copying FROM and
   simply adding a reference to it.  So the operation takes place in
   constant time.  However, there's no reason not to extend this to
   mutable nodes --- it's just more code.)

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_copy (svn_fs_root_t *from_root,
                          const char *from_path,
                          svn_fs_root_t *to_root,
                          const char *to_path,
                          apr_pool_t *pool);





/* Files.  */

/* Set *LENGTH_P to the length of the file PATH in ROOT, in bytes.  Do
   any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_file_length (apr_off_t *length_p,
                                 svn_fs_root_t *root,
                                 const char *path,
                                 apr_pool_t *pool);


/* Set *CONTENTS to a readable generic stream will yield the contents
   of the file PATH in ROOT.  Allocate the stream in POOL.  You can
   only use *CONTENTS for as long as the underlying filesystem is
   open.  */
svn_error_t *svn_fs_file_contents (svn_stream_t **contents,
                                   svn_fs_root_t *root,
                                   const char *path,
                                   apr_pool_t *pool);


/* Create a new file named PATH in ROOT.  The file's initial contents
   are the empty string, and it has no properties.  ROOT must be the
   root of a transaction, not a revision.

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_make_file (svn_fs_root_t *root,
                               const char *path,
                               apr_pool_t *pool);


/* Apply a text delta to the file PATH in ROOT.  ROOT must be the root
   of a transaction, not a revision.

   Set *CONTENTS_P to a function ready to receive text delta windows
   describing how to change the file's contents, relative to its
   current contents.  Set *CONTENTS_BATON_P to a baton to pass to
   *CONTENTS_P.

   If PATH does not exist in ROOT, return an error.  (You cannot use
   this routine to create new files;  use svn_fs_make_file to create
   an empty file first.)

   Do any necessary temporary allocation in POOL.  */
svn_error_t *svn_fs_apply_textdelta (svn_txdelta_window_handler_t *contents_p,
                                     void **contents_baton_p,
                                     svn_fs_root_t *root,
                                     const char *path,
                                     apr_pool_t *pool);


/* Set *STREAM_P to a pointer to a delta stream that will turn the
   contents of the file SOURCE into the contents of the file TARGET.
   If SOURCE_ROOT is zero, use a file with zero length as the source.

   This function does not compare the two files' properties.

   Allocate *STREAM_P, and do any necessary temporary allocation, in
   POOL.  */
svn_error_t *
svn_fs_get_file_delta_stream (svn_txdelta_stream_t **stream_p,
                              svn_fs_root_t *source_root,
                              const char *source_path,
                              svn_fs_root_t *target_root,
                              const char *target_path,
                              apr_pool_t *pool);


/* 
 * local variables:
 * truncate-lines: t
 * end:
 */