File Manager

003 File Manager

Current Path: /usr/src/contrib/subversion/subversion/libsvn_fs_x

usr / src / contrib / subversion / subversion / libsvn_fs_x /

📁 ..
📄 TODO(9.58 KB)
📄 batch_fsync.c(17.36 KB)
📄 batch_fsync.h(3.74 KB)
📄 cached_data.c(124.18 KB)
📄 cached_data.h(8.98 KB)
📄 caching.c(25.26 KB)
📄 changes.c(18.9 KB)
📄 changes.h(5.56 KB)
📄 dag.c(33.9 KB)
📄 dag.h(18.94 KB)
📄 dag_cache.c(37.62 KB)
📄 dag_cache.h(6.8 KB)
📄 fs.c(20.49 KB)
📄 fs.h(20.55 KB)
📄 fs_id.c(9.6 KB)
📄 fs_id.h(2.37 KB)
📄 fs_init.h(1.24 KB)
📄 fs_x.c(51.32 KB)
📄 fs_x.h(8.89 KB)
📄 hotcopy.c(32.16 KB)
📄 hotcopy.h(2.05 KB)
📄 id.c(4.92 KB)
📄 id.h(4.41 KB)
📄 index.c(136.28 KB)
📄 index.h(17.5 KB)
📄 libsvn_fs_x.pc.in(387 B)
📄 lock.c(45.17 KB)
📄 lock.h(3.94 KB)
📄 low_level.c(40.89 KB)
📄 low_level.h(9.21 KB)
📄 noderevs.c(31.18 KB)
📄 noderevs.h(5.39 KB)
📄 pack.c(82.45 KB)
📄 pack.h(2.33 KB)
📄 recovery.c(12.25 KB)
📄 recovery.h(1.46 KB)
📄 rep-cache-db.h(2.25 KB)
📄 rep-cache-db.sql(2.23 KB)
📄 rep-cache.c(14 KB)
📄 rep-cache.h(4.26 KB)
📄 reps.c(29.63 KB)
📄 reps.h(7.3 KB)
📄 rev_file.c(17.15 KB)
📄 rev_file.h(7.15 KB)
📄 revprops.c(59.51 KB)
📄 revprops.h(4.99 KB)
📄 string_table.c(29.61 KB)
📄 string_table.h(5.06 KB)
📄 structure(14.88 KB)
📄 temp_serializer.c(37.31 KB)
📄 temp_serializer.h(10.7 KB)
📄 transaction.c(147.9 KB)
📄 transaction.h(13.26 KB)
📄 tree.c(120.57 KB)
📄 tree.h(3.98 KB)
📄 util.c(22.6 KB)
📄 util.h(16.85 KB)
📄 verify.c(30.47 KB)
📄 verify.h(1.78 KB)

Editing: dag_cache.h

/* dag_cache.h : Interface to the DAG walker and node cache.
 *
 * ====================================================================
 *    Licensed to the Apache Software Foundation (ASF) under one
 *    or more contributor license agreements.  See the NOTICE file
 *    distributed with this work for additional information
 *    regarding copyright ownership.  The ASF licenses this file
 *    to you under the Apache License, Version 2.0 (the
 *    "License"); you may not use this file except in compliance
 *    with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing,
 *    software distributed under the License is distributed on an
 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *    KIND, either express or implied.  See the License for the
 *    specific language governing permissions and limitations
 *    under the License.
 * ====================================================================
 */

#ifndef SVN_LIBSVN_FS_X_DAG_CACHE_H
#define SVN_LIBSVN_FS_X_DAG_CACHE_H

#include "dag.h"

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

/* In RESULT_POOL, create an instance of a DAG node cache. */
svn_fs_x__dag_cache_t*
svn_fs_x__create_dag_cache(apr_pool_t *result_pool);

/* Invalidate cache entries for PATH within ROOT and any of its children. */
void
svn_fs_x__invalidate_dag_cache(svn_fs_root_t *root,
                               const char *path);

/* Flag type used in svn_fs_x__dag_path_t to determine where the
   respective node got its copy ID from. */
typedef enum svn_fs_x__copy_id_inherit_t
{
  svn_fs_x__copy_id_inherit_unknown = 0,
  svn_fs_x__copy_id_inherit_self,
  svn_fs_x__copy_id_inherit_parent,
  svn_fs_x__copy_id_inherit_new

} svn_fs_x__copy_id_inherit_t;

/* Flags for svn_fs_x__get_dag_path.  */
typedef enum svn_fs_x__dag_path_flags_t {

/* The last component of the PATH need not exist.  (All parent
     directories must exist, as usual.)  If the last component doesn't
     exist, simply leave the `node' member of the bottom parent_path
     component zero.  */
  svn_fs_x__dag_path_last_optional = 1,

/* The caller wants a NULL path object instead of an error if the
     path cannot be found. */
  svn_fs_x__dag_path_allow_null = 2
} svn_fs_x__dag_path_flags_t;

/* A linked list representing the path from a node up to a root
   directory.  We use this for cloning, and for operations that need
   to deal with both a node and its parent directory.  For example, a
   `delete' operation needs to know that the node actually exists, but
   also needs to change the parent directory.  */
typedef struct svn_fs_x__dag_path_t
{
  /* A node along the path.  This could be the final node, one of its
     parents, or the root.  Every parent path ends with an element for
     the root directory.  */
  dag_node_t *node;

/* The name NODE has in its parent directory.  This is zero for the
     root directory, which (obviously) has no name in its parent.  */
  char *entry;

/* The parent of NODE, or zero if NODE is the root directory.  */
  struct svn_fs_x__dag_path_t *parent;

/* The copy ID inheritance style. */
  svn_fs_x__copy_id_inherit_t copy_inherit;

/* If copy ID inheritance style is copy_id_inherit_new, this is the
     path which should be implicitly copied; otherwise, this is NULL. */
  const char *copy_src_path;

} svn_fs_x__dag_path_t;

/* Open the node identified by PATH in ROOT, allocating in RESULT_POOL.
   Set *DAG_PATH_P to a path from the node up to ROOT.  The resulting
   **DAG_PATH_P value is guaranteed to contain at least one element,
   for the root directory.  PATH must be in canonical form.  Allocate
   temporaries from SCRATCH_POOL.

If resulting *PARENT_PATH_P will eventually be made mutable and
   modified, or if copy ID inheritance information is otherwise needed,
   IS_TXN_PATH must be set.  If IS_TXN_PATH is FALSE, no copy ID
   inheritance information will be calculated for the *PARENT_PATH_P chain.

If FLAGS & svn_fs_x__dag_path_last_optional is zero, return the error
   SVN_ERR_FS_NOT_FOUND if the node PATH refers to does not exist.  If
   non-zero, require all the parent directories to exist as normal,
   but if the final path component doesn't exist, simply return a path
   whose bottom `node' member is zero.  This option is useful for
   callers that create new nodes --- we find the parent directory for
   them, and tell them whether the entry exists already.

If FLAGS & svn_fs_x__dag_path_allow_null is non-zero, set the
   *PARENT_PATH_P to NULL if any node in the path could not be found.

NOTE: Public interfaces which only *read* from the filesystem
   should not call this function directly, but should instead use
   svn_fs_x__get_dag_node().
*/
svn_error_t *
svn_fs_x__get_dag_path(svn_fs_x__dag_path_t **dag_path_p,
                       svn_fs_root_t *root,
                       const char *path,
                       int flags,
                       svn_boolean_t is_txn_path,
                       apr_pool_t *result_pool,
                       apr_pool_t *scratch_pool);

/* Make the node referred to by PARENT_PATH mutable, if it isn't already,
   allocating from RESULT_POOL.  ROOT must be the root from which
   PARENT_PATH descends.  Clone any parent directories as needed.
   Adjust the dag nodes in PARENT_PATH to refer to the clones.  Use
   ERROR_PATH in error messages.  Use SCRATCH_POOL for temporaries. */
svn_error_t *
svn_fs_x__make_path_mutable(svn_fs_root_t *root,
                            svn_fs_x__dag_path_t *parent_path,
                            const char *error_path,
                            apr_pool_t *result_pool,
                            apr_pool_t *scratch_pool);

/* Open the node identified by PATH in ROOT.  Set *DAG_NODE_P to a temporary
   reference to the node we find.  That reference will become invalid upon
   the next access to the DAG cache.

Return the error SVN_ERR_FS_NOT_FOUND if this node doesn't exist.
 */
svn_error_t *
svn_fs_x__get_temp_dag_node(dag_node_t **node_p,
                            svn_fs_root_t *root,
                            const char *path,
                            apr_pool_t *scratch_pool);

/* Open the node identified by PATH in ROOT.  Set *DAG_NODE_P to the
   node we find, allocated in RESULT_POOL.  Return the error
   SVN_ERR_FS_NOT_FOUND if this node doesn't exist.  Use SCRATCH_POOL
   for temporary allocations.
 */
svn_error_t *
svn_fs_x__get_dag_node(dag_node_t **dag_node_p,
                       svn_fs_root_t *root,
                       const char *path,
                       apr_pool_t *result_pool,
                       apr_pool_t *scratch_pool);

/* Add / update the NODE in the node cache. */
void
svn_fs_x__update_dag_cache(dag_node_t *node);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* SVN_LIBSVN_FS_X_DAG_CACHE_H */

003 File Manager

Editing: dag_cache.h

Upload File

Create Folder