fs.py

来自「subversion-1.4.5.tar.gz 配置svn的源码」· Python 代码 · 共 967 行 · 第 1/3 页

    return apply(_fs.svn_fs_check_path, args)

def svn_fs_node_history(*args):
    """
    svn_fs_node_history(svn_fs_history_t history_p, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_node_history, args)

def svn_fs_history_prev(*args):
    """
    svn_fs_history_prev(svn_fs_history_t prev_history_p, svn_fs_history_t history, 
        svn_boolean_t cross_copies, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_history_prev, args)

def svn_fs_history_location(*args):
    """
    svn_fs_history_location(char path, svn_revnum_t revision, svn_fs_history_t history, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_history_location, args)

def svn_fs_is_dir(*args):
    """
    svn_fs_is_dir(svn_boolean_t is_dir, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_is_dir, args)

def svn_fs_is_file(*args):
    """
    svn_fs_is_file(svn_boolean_t is_file, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_is_file, args)

def svn_fs_node_id(*args):
    """svn_fs_node_id(svn_fs_id_t id_p, svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_node_id, args)

def svn_fs_node_created_rev(*args):
    """
    svn_fs_node_created_rev(svn_revnum_t revision, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_node_created_rev, args)

def svn_fs_node_created_path(*args):
    """svn_fs_node_created_path(char created_path, svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_node_created_path, args)

def svn_fs_node_prop(*args):
    """
    svn_fs_node_prop(svn_string_t value_p, svn_fs_root_t root, char path, 
        char propname, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_node_prop, args)

def svn_fs_node_proplist(*args):
    """
    svn_fs_node_proplist(apr_hash_t table_p, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_node_proplist, args)

def svn_fs_change_node_prop(*args):
    """
    svn_fs_change_node_prop(svn_fs_root_t root, char path, char name, svn_string_t value, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_change_node_prop, args)

def svn_fs_props_changed(*args):
    """
    svn_fs_props_changed(svn_boolean_t changed_p, svn_fs_root_t root1, char path1, 
        svn_fs_root_t root2, char path2, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_props_changed, args)

def svn_fs_copied_from(*args):
    """
    svn_fs_copied_from(svn_revnum_t rev_p, char path_p, svn_fs_root_t root, 
        char path, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_copied_from, args)

def svn_fs_closest_copy(*args):
    """
    svn_fs_closest_copy(svn_fs_root_t root_p, char path_p, svn_fs_root_t root, 
        char path, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_closest_copy, args)

def svn_fs_merge(*args):
    """
    svn_fs_merge(char conflict_p, svn_fs_root_t source_root, char source_path, 
        svn_fs_root_t target_root, char target_path, 
        svn_fs_root_t ancestor_root, char ancestor_path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_merge, args)
class svn_fs_dirent_t:
    """Proxy of C svn_fs_dirent_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_fs_dirent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_fs_dirent_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_fs_dirent_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["name"] = _fs.svn_fs_dirent_t_name_set
    __swig_getmethods__["name"] = _fs.svn_fs_dirent_t_name_get
    __swig_setmethods__["id"] = _fs.svn_fs_dirent_t_id_set
    __swig_getmethods__["id"] = _fs.svn_fs_dirent_t_id_get
    __swig_setmethods__["kind"] = _fs.svn_fs_dirent_t_kind_set
    __swig_getmethods__["kind"] = _fs.svn_fs_dirent_t_kind_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_fs_dirent_t"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()
      value = _swig_getattr(self, self.__class__, name)
      try:
        old_dict = self.__dict__["_member_dicts"][name]
        value.__dict__["_parent_pool"] = old_dict.get("_parent_pool")
        value.__dict__["_member_dicts"] = old_dict.get("_member_dicts")
        value.__dict__["_is_valid"] = old_dict.get("_is_valid")
        value.assert_valid()
      except KeyError:
        pass
      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()
      try:
        self.__dict__.setdefault("_member_dicts",{})[name] = value.__dict__
      except AttributeError:
        pass
      return _swig_setattr(self, self.__class__, name, value)


class svn_fs_dirent_tPtr(svn_fs_dirent_t):
    def __init__(self, this):
        _swig_setattr(self, svn_fs_dirent_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_fs_dirent_t, 'thisown', 0)
        _swig_setattr(self, svn_fs_dirent_t,self.__class__,svn_fs_dirent_t)
_fs.svn_fs_dirent_t_swigregister(svn_fs_dirent_tPtr)


def svn_fs_dir_entries(*args):
    """
    svn_fs_dir_entries(apr_hash_t entries_p, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_dir_entries, args)

def svn_fs_make_dir(*args):
    """svn_fs_make_dir(svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_make_dir, args)

def svn_fs_delete(*args):
    """svn_fs_delete(svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_delete, args)

def svn_fs_copy(*args):
    """
    svn_fs_copy(svn_fs_root_t from_root, char from_path, svn_fs_root_t to_root, 
        char to_path, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_copy, args)

def svn_fs_revision_link(*args):
    """
    svn_fs_revision_link(svn_fs_root_t from_root, svn_fs_root_t to_root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_revision_link, args)

def svn_fs_file_length(*args):
    """
    svn_fs_file_length(svn_filesize_t length_p, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_file_length, args)

def svn_fs_file_md5_checksum(*args):
    """
    svn_fs_file_md5_checksum(unsigned char digest, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_file_md5_checksum, args)

def svn_fs_file_contents(*args):
    """
    svn_fs_file_contents(svn_stream_t contents, svn_fs_root_t root, char path, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_file_contents, args)

def svn_fs_make_file(*args):
    """svn_fs_make_file(svn_fs_root_t root, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_make_file, args)

def svn_fs_apply_textdelta(*args):
    """
    svn_fs_apply_textdelta(svn_txdelta_window_handler_t contents_p, void contents_baton_p, 
        svn_fs_root_t root, char path, char base_checksum, 
        char result_checksum, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_apply_textdelta, args)

def svn_fs_apply_text(*args):
    """
    svn_fs_apply_text(svn_stream_t contents_p, svn_fs_root_t root, char path, 
        char result_checksum, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_apply_text, args)

def svn_fs_contents_changed(*args):
    """
    svn_fs_contents_changed(svn_boolean_t changed_p, svn_fs_root_t root1, char path1, 
        svn_fs_root_t root2, char path2, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_contents_changed, args)

def svn_fs_youngest_rev(*args):
    """svn_fs_youngest_rev(svn_revnum_t youngest_p, svn_fs_t fs, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_youngest_rev, args)

def svn_fs_deltify_revision(*args):
    """svn_fs_deltify_revision(svn_fs_t fs, svn_revnum_t revision, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_deltify_revision, args)

def svn_fs_revision_prop(*args):
    """
    svn_fs_revision_prop(svn_string_t value_p, svn_fs_t fs, svn_revnum_t rev, 
        char propname, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_revision_prop, args)

def svn_fs_revision_proplist(*args):
    """
    svn_fs_revision_proplist(apr_hash_t table_p, svn_fs_t fs, svn_revnum_t rev, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_revision_proplist, args)

def svn_fs_change_rev_prop(*args):
    """
    svn_fs_change_rev_prop(svn_fs_t fs, svn_revnum_t rev, char name, svn_string_t value, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_change_rev_prop, args)

def svn_fs_get_file_delta_stream(*args):
    """
    svn_fs_get_file_delta_stream(svn_txdelta_stream_t stream_p, svn_fs_root_t source_root, 
        char source_path, svn_fs_root_t target_root, 
        char target_path, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_get_file_delta_stream, args)

def svn_fs_get_uuid(*args):
    """svn_fs_get_uuid(svn_fs_t fs, char uuid, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_get_uuid, args)

def svn_fs_set_uuid(*args):
    """svn_fs_set_uuid(svn_fs_t fs, char uuid, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_set_uuid, args)

def svn_fs_lock(*args):
    """
    svn_fs_lock(svn_lock_t lock, svn_fs_t fs, char path, char token, 
        char comment, svn_boolean_t is_dav_comment, 
        apr_time_t expiration_date, svn_revnum_t current_rev, 
        svn_boolean_t steal_lock, apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_lock, args)

def svn_fs_generate_lock_token(*args):
    """svn_fs_generate_lock_token(char token, svn_fs_t fs, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_generate_lock_token, args)

def svn_fs_unlock(*args):
    """
    svn_fs_unlock(svn_fs_t fs, char path, char token, svn_boolean_t break_lock, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_unlock, args)

def svn_fs_get_lock(*args):
    """svn_fs_get_lock(svn_lock_t lock, svn_fs_t fs, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_get_lock, args)

def svn_fs_get_locks(*args):
    """
    svn_fs_get_locks(svn_fs_t fs, char path, svn_fs_get_locks_callback_t get_locks_func, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_fs.svn_fs_get_locks, args)

def svn_fs_print_modules(*args):
    """svn_fs_print_modules(svn_stringbuf_t output, apr_pool_t pool) -> svn_error_t"""
    return apply(_fs.svn_fs_print_modules, args)
class svn_fs_t:
    """Proxy of C svn_fs_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_fs_t, name, value)
    __swig_getmethods__ = {}