# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _diff

def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import core

def svn_diff_version(*args):
    """svn_diff_version() -> svn_version_t"""
    return apply(_diff.svn_diff_version, args)
svn_diff_datasource_original = _diff.svn_diff_datasource_original
svn_diff_datasource_modified = _diff.svn_diff_datasource_modified
svn_diff_datasource_latest = _diff.svn_diff_datasource_latest
svn_diff_datasource_ancestor = _diff.svn_diff_datasource_ancestor
class svn_diff_fns_t:
    """Proxy of C svn_diff_fns_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_fns_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_fns_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_diff_fns_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["datasource_open"] = _diff.svn_diff_fns_t_datasource_open_set
    __swig_getmethods__["datasource_open"] = _diff.svn_diff_fns_t_datasource_open_get
    __swig_setmethods__["datasource_close"] = _diff.svn_diff_fns_t_datasource_close_set
    __swig_getmethods__["datasource_close"] = _diff.svn_diff_fns_t_datasource_close_get
    __swig_setmethods__["datasource_get_next_token"] = _diff.svn_diff_fns_t_datasource_get_next_token_set
    __swig_getmethods__["datasource_get_next_token"] = _diff.svn_diff_fns_t_datasource_get_next_token_get
    __swig_setmethods__["token_compare"] = _diff.svn_diff_fns_t_token_compare_set
    __swig_getmethods__["token_compare"] = _diff.svn_diff_fns_t_token_compare_get
    __swig_setmethods__["token_discard"] = _diff.svn_diff_fns_t_token_discard_set
    __swig_getmethods__["token_discard"] = _diff.svn_diff_fns_t_token_discard_get
    __swig_setmethods__["token_discard_all"] = _diff.svn_diff_fns_t_token_discard_all_set
    __swig_getmethods__["token_discard_all"] = _diff.svn_diff_fns_t_token_discard_all_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_diff_fns_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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()




      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def datasource_open(self, *args):
      return svn_diff_fns_invoke_datasource_open(self, *args)

    def datasource_close(self, *args):
      return svn_diff_fns_invoke_datasource_close(self, *args)

    def datasource_get_next_token(self, *args):
      return svn_diff_fns_invoke_datasource_get_next_token(self, *args)

    def token_compare(self, *args):
      return svn_diff_fns_invoke_token_compare(self, *args)

    def token_discard(self, *args):
      return svn_diff_fns_invoke_token_discard(self, *args)

    def token_discard_all(self, *args):
      return svn_diff_fns_invoke_token_discard_all(self, *args)

    def __init__(self, *args):
        """__init__(self) -> svn_diff_fns_t"""
        _swig_setattr(self, svn_diff_fns_t, 'this', apply(_diff.new_svn_diff_fns_t, args))
        _swig_setattr(self, svn_diff_fns_t, 'thisown', 1)
    def __del__(self, destroy=_diff.delete_svn_diff_fns_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_diff_fns_tPtr(svn_diff_fns_t):
    def __init__(self, this):
        _swig_setattr(self, svn_diff_fns_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_diff_fns_t, 'thisown', 0)
        _swig_setattr(self, svn_diff_fns_t,self.__class__,svn_diff_fns_t)
_diff.svn_diff_fns_t_swigregister(svn_diff_fns_tPtr)


def svn_diff_diff(*args):
    """
    svn_diff_diff(svn_diff_t diff, void diff_baton, svn_diff_fns_t diff_fns, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_diff, args)

def svn_diff_diff3(*args):
    """
    svn_diff_diff3(svn_diff_t diff, void diff_baton, svn_diff_fns_t diff_fns, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_diff3, args)

def svn_diff_diff4(*args):
    """
    svn_diff_diff4(svn_diff_t diff, void diff_baton, svn_diff_fns_t diff_fns, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_diff4, args)

def svn_diff_contains_conflicts(*args):
    """svn_diff_contains_conflicts(svn_diff_t diff) -> svn_boolean_t"""
    return apply(_diff.svn_diff_contains_conflicts, args)

def svn_diff_contains_diffs(*args):
    """svn_diff_contains_diffs(svn_diff_t diff) -> svn_boolean_t"""
    return apply(_diff.svn_diff_contains_diffs, args)
class svn_diff_output_fns_t:
    """Proxy of C svn_diff_output_fns_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_output_fns_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_output_fns_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_diff_output_fns_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["output_common"] = _diff.svn_diff_output_fns_t_output_common_set
    __swig_getmethods__["output_common"] = _diff.svn_diff_output_fns_t_output_common_get
    __swig_setmethods__["output_diff_modified"] = _diff.svn_diff_output_fns_t_output_diff_modified_set
    __swig_getmethods__["output_diff_modified"] = _diff.svn_diff_output_fns_t_output_diff_modified_get
    __swig_setmethods__["output_diff_latest"] = _diff.svn_diff_output_fns_t_output_diff_latest_set
    __swig_getmethods__["output_diff_latest"] = _diff.svn_diff_output_fns_t_output_diff_latest_get
    __swig_setmethods__["output_diff_common"] = _diff.svn_diff_output_fns_t_output_diff_common_set
    __swig_getmethods__["output_diff_common"] = _diff.svn_diff_output_fns_t_output_diff_common_get
    __swig_setmethods__["output_conflict"] = _diff.svn_diff_output_fns_t_output_conflict_set
    __swig_getmethods__["output_conflict"] = _diff.svn_diff_output_fns_t_output_conflict_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_diff_output_fns_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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()




      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def output_common(self, *args):
      return svn_diff_output_fns_invoke_output_common(self, *args)

    def output_diff_modified(self, *args):
      return svn_diff_output_fns_invoke_output_diff_modified(self, *args)

    def output_diff_latest(self, *args):
      return svn_diff_output_fns_invoke_output_diff_latest(self, *args)

    def output_diff_common(self, *args):
      return svn_diff_output_fns_invoke_output_diff_common(self, *args)

    def output_conflict(self, *args):
      return svn_diff_output_fns_invoke_output_conflict(self, *args)

    def __init__(self, *args):
        """__init__(self) -> svn_diff_output_fns_t"""
        _swig_setattr(self, svn_diff_output_fns_t, 'this', apply(_diff.new_svn_diff_output_fns_t, args))
        _swig_setattr(self, svn_diff_output_fns_t, 'thisown', 1)
    def __del__(self, destroy=_diff.delete_svn_diff_output_fns_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_diff_output_fns_tPtr(svn_diff_output_fns_t):
    def __init__(self, this):
        _swig_setattr(self, svn_diff_output_fns_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_diff_output_fns_t, 'thisown', 0)
        _swig_setattr(self, svn_diff_output_fns_t,self.__class__,svn_diff_output_fns_t)
_diff.svn_diff_output_fns_t_swigregister(svn_diff_output_fns_tPtr)

svn_diff_conflict_display_modified_latest = _diff.svn_diff_conflict_display_modified_latest
svn_diff_conflict_display_resolved_modified_latest = _diff.svn_diff_conflict_display_resolved_modified_latest
svn_diff_conflict_display_modified_original_latest = _diff.svn_diff_conflict_display_modified_original_latest
svn_diff_conflict_display_modified = _diff.svn_diff_conflict_display_modified
svn_diff_conflict_display_latest = _diff.svn_diff_conflict_display_latest
svn_diff_conflict_display_only_conflicts = _diff.svn_diff_conflict_display_only_conflicts

def svn_diff_output(*args):
    """svn_diff_output(svn_diff_t diff, void output_baton, svn_diff_output_fns_t output_fns) -> svn_error_t"""
    return apply(_diff.svn_diff_output, args)
svn_diff_file_ignore_space_none = _diff.svn_diff_file_ignore_space_none
svn_diff_file_ignore_space_change = _diff.svn_diff_file_ignore_space_change
svn_diff_file_ignore_space_all = _diff.svn_diff_file_ignore_space_all
class svn_diff_file_options_t:
    """Proxy of C svn_diff_file_options_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_file_options_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_file_options_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_diff_file_options_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["ignore_space"] = _diff.svn_diff_file_options_t_ignore_space_set
    __swig_getmethods__["ignore_space"] = _diff.svn_diff_file_options_t_ignore_space_get
    __swig_setmethods__["ignore_eol_style"] = _diff.svn_diff_file_options_t_ignore_eol_style_set
    __swig_getmethods__["ignore_eol_style"] = _diff.svn_diff_file_options_t_ignore_eol_style_get
    __swig_setmethods__["show_c_function"] = _diff.svn_diff_file_options_t_show_c_function_set
    __swig_getmethods__["show_c_function"] = _diff.svn_diff_file_options_t_show_c_function_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_diff_file_options_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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()




      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __init__(self, *args):
        """__init__(self) -> svn_diff_file_options_t"""
        _swig_setattr(self, svn_diff_file_options_t, 'this', apply(_diff.new_svn_diff_file_options_t, args))
        _swig_setattr(self, svn_diff_file_options_t, 'thisown', 1)
    def __del__(self, destroy=_diff.delete_svn_diff_file_options_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_diff_file_options_tPtr(svn_diff_file_options_t):
    def __init__(self, this):
        _swig_setattr(self, svn_diff_file_options_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_diff_file_options_t, 'thisown', 0)
        _swig_setattr(self, svn_diff_file_options_t,self.__class__,svn_diff_file_options_t)
_diff.svn_diff_file_options_t_swigregister(svn_diff_file_options_tPtr)


def svn_diff_file_options_create(*args):
    """svn_diff_file_options_create(apr_pool_t pool) -> svn_diff_file_options_t"""
    return apply(_diff.svn_diff_file_options_create, args)

def svn_diff_file_options_parse(*args):
    """
    svn_diff_file_options_parse(svn_diff_file_options_t options, apr_array_header_t args, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_options_parse, args)

def svn_diff_file_diff_2(*args):
    """
    svn_diff_file_diff_2(svn_diff_t diff, char original, char modified, svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_diff_2, args)

def svn_diff_file_diff(*args):
    """svn_diff_file_diff(svn_diff_t diff, char original, char modified, apr_pool_t pool) -> svn_error_t"""
    return apply(_diff.svn_diff_file_diff, args)

def svn_diff_file_diff3_2(*args):
    """
    svn_diff_file_diff3_2(svn_diff_t diff, char original, char modified, char latest, 
        svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_diff3_2, args)

def svn_diff_file_diff3(*args):
    """
    svn_diff_file_diff3(svn_diff_t diff, char original, char modified, char latest, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_diff3, args)

def svn_diff_file_diff4_2(*args):
    """
    svn_diff_file_diff4_2(svn_diff_t diff, char original, char modified, char latest, 
        char ancestor, svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_diff4_2, args)

def svn_diff_file_diff4(*args):
    """
    svn_diff_file_diff4(svn_diff_t diff, char original, char modified, char latest, 
        char ancestor, apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_diff4, args)

def svn_diff_file_output_unified3(*args):
    """
    svn_diff_file_output_unified3(svn_stream_t output_stream, svn_diff_t diff, char original_path, 
        char modified_path, char original_header, 
        char modified_header, char header_encoding, 
        char relative_to_dir, svn_boolean_t show_c_function, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_output_unified3, args)

def svn_diff_file_output_unified2(*args):
    """
    svn_diff_file_output_unified2(svn_stream_t output_stream, svn_diff_t diff, char original_path, 
        char modified_path, char original_header, 
        char modified_header, char header_encoding, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_output_unified2, args)

def svn_diff_file_output_unified(*args):
    """
    svn_diff_file_output_unified(svn_stream_t output_stream, svn_diff_t diff, char original_path, 
        char modified_path, char original_header, 
        char modified_header, apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_output_unified, args)

def svn_diff_file_output_merge2(*args):
    """
    svn_diff_file_output_merge2(svn_stream_t output_stream, svn_diff_t diff, char original_path, 
        char modified_path, char latest_path, 
        char conflict_original, char conflict_modified, 
        char conflict_latest, char conflict_separator, 
        svn_diff_conflict_display_style_t conflict_style, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_output_merge2, args)

def svn_diff_file_output_merge(*args):
    """
    svn_diff_file_output_merge(svn_stream_t output_stream, svn_diff_t diff, char original_path, 
        char modified_path, char latest_path, 
        char conflict_original, char conflict_modified, 
        char conflict_latest, char conflict_separator, 
        svn_boolean_t display_original_in_conflict, 
        svn_boolean_t display_resolved_conflicts, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_file_output_merge, args)

def svn_diff_mem_string_diff(*args):
    """
    svn_diff_mem_string_diff(svn_diff_t diff, svn_string_t original, svn_string_t modified, 
        svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_diff, args)

def svn_diff_mem_string_diff3(*args):
    """
    svn_diff_mem_string_diff3(svn_diff_t diff, svn_string_t original, svn_string_t modified, 
        svn_string_t latest, svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_diff3, args)

def svn_diff_mem_string_diff4(*args):
    """
    svn_diff_mem_string_diff4(svn_diff_t diff, svn_string_t original, svn_string_t modified, 
        svn_string_t latest, svn_string_t ancestor, 
        svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_diff4, args)

def svn_diff_mem_string_output_unified(*args):
    """
    svn_diff_mem_string_output_unified(svn_stream_t output_stream, svn_diff_t diff, char original_header, 
        char modified_header, char header_encoding, 
        svn_string_t original, svn_string_t modified, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_output_unified, args)

def svn_diff_mem_string_output_merge2(*args):
    """
    svn_diff_mem_string_output_merge2(svn_stream_t output_stream, svn_diff_t diff, svn_string_t original, 
        svn_string_t modified, svn_string_t latest, 
        char conflict_original, char conflict_modified, 
        char conflict_latest, char conflict_separator, 
        svn_diff_conflict_display_style_t style, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_output_merge2, args)

def svn_diff_mem_string_output_merge(*args):
    """
    svn_diff_mem_string_output_merge(svn_stream_t output_stream, svn_diff_t diff, svn_string_t original, 
        svn_string_t modified, svn_string_t latest, 
        char conflict_original, char conflict_modified, 
        char conflict_latest, char conflict_separator, 
        svn_boolean_t display_original_in_conflict, 
        svn_boolean_t display_resolved_conflicts, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_diff.svn_diff_mem_string_output_merge, args)
class svn_diff_t:
    """Proxy of C svn_diff_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_diff_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_diff_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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()




      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)


class svn_diff_tPtr(svn_diff_t):
    def __init__(self, this):
        _swig_setattr(self, svn_diff_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_diff_t, 'thisown', 0)
        _swig_setattr(self, svn_diff_t,self.__class__,svn_diff_t)
_diff.svn_diff_t_swigregister(svn_diff_tPtr)


def svn_diff_fns_invoke_datasource_open(*args):
    """svn_diff_fns_invoke_datasource_open(svn_diff_fns_t _obj, void diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
    return apply(_diff.svn_diff_fns_invoke_datasource_open, args)

def svn_diff_fns_invoke_datasource_close(*args):
    """svn_diff_fns_invoke_datasource_close(svn_diff_fns_t _obj, void diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
    return apply(_diff.svn_diff_fns_invoke_datasource_close, args)

def svn_diff_fns_invoke_datasource_get_next_token(*args):
    """
    svn_diff_fns_invoke_datasource_get_next_token(svn_diff_fns_t _obj, apr_uint32_t hash, void token, 
        void diff_baton, svn_diff_datasource_e datasource) -> svn_error_t
    """
    return apply(_diff.svn_diff_fns_invoke_datasource_get_next_token, args)

def svn_diff_fns_invoke_token_compare(*args):
    """
    svn_diff_fns_invoke_token_compare(svn_diff_fns_t _obj, void diff_baton, void ltoken, 
        void rtoken, int compare) -> svn_error_t
    """
    return apply(_diff.svn_diff_fns_invoke_token_compare, args)

def svn_diff_fns_invoke_token_discard(*args):
    """svn_diff_fns_invoke_token_discard(svn_diff_fns_t _obj, void diff_baton, void token)"""
    return apply(_diff.svn_diff_fns_invoke_token_discard, args)

def svn_diff_fns_invoke_token_discard_all(*args):
    """svn_diff_fns_invoke_token_discard_all(svn_diff_fns_t _obj, void diff_baton)"""
    return apply(_diff.svn_diff_fns_invoke_token_discard_all, args)

def svn_diff_output_fns_invoke_output_common(*args):
    """
    svn_diff_output_fns_invoke_output_common(svn_diff_output_fns_t _obj, void output_baton, apr_off_t original_start, 
        apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, 
        apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t
    """
    return apply(_diff.svn_diff_output_fns_invoke_output_common, args)

def svn_diff_output_fns_invoke_output_diff_modified(*args):
    """
    svn_diff_output_fns_invoke_output_diff_modified(svn_diff_output_fns_t _obj, void output_baton, apr_off_t original_start, 
        apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, 
        apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t
    """
    return apply(_diff.svn_diff_output_fns_invoke_output_diff_modified, args)

def svn_diff_output_fns_invoke_output_diff_latest(*args):
    """
    svn_diff_output_fns_invoke_output_diff_latest(svn_diff_output_fns_t _obj, void output_baton, apr_off_t original_start, 
        apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, 
        apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t
    """
    return apply(_diff.svn_diff_output_fns_invoke_output_diff_latest, args)

def svn_diff_output_fns_invoke_output_diff_common(*args):
    """
    svn_diff_output_fns_invoke_output_diff_common(svn_diff_output_fns_t _obj, void output_baton, apr_off_t original_start, 
        apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, 
        apr_off_t latest_start, apr_off_t latest_length) -> svn_error_t
    """
    return apply(_diff.svn_diff_output_fns_invoke_output_diff_common, args)

def svn_diff_output_fns_invoke_output_conflict(*args):
    """
    svn_diff_output_fns_invoke_output_conflict(svn_diff_output_fns_t _obj, void output_baton, apr_off_t original_start, 
        apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, 
        apr_off_t latest_start, apr_off_t latest_length, 
        svn_diff_t resolved_diff) -> svn_error_t
    """
    return apply(_diff.svn_diff_output_fns_invoke_output_conflict, args)

