/* * ==================================================================== * 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. * ==================================================================== * * svn_delta.i: SWIG interface file for svn_delta.h */ #if defined(SWIGPYTHON) %module(package="libsvn") delta #elif defined(SWIGPERL) %module "SVN::_Delta" #elif defined(SWIGRUBY) %module "svn::ext::delta" #endif %include svn_global.swg %import core.i #ifdef SWIGRUBY %ignore svn_compat_wrap_file_rev_handler; #endif /* ----------------------------------------------------------------------- %apply-ing of typemaps defined elsewhere */ %apply const char *MAY_BE_NULL { const char *error_info, const char *copyfrom_path, const char *copy_path, const char *base_checksum, const char *text_checksum }; #ifdef SWIGPYTHON %apply svn_stream_t *WRAPPED_STREAM { svn_stream_t * }; #endif /* ----------------------------------------------------------------------- mark window.new_data as readonly since we would need a pool to set it properly (e.g. to allocate an svn_string_t structure). */ %immutable svn_txdelta_window_t::new_data; /* ----------------------------------------------------------------------- thunk editors for the various language bindings. */ #ifdef SWIGPYTHON void svn_swig_py_make_editor(const svn_delta_editor_t **editor, void **edit_baton, PyObject *py_editor, apr_pool_t *pool); #endif #ifdef SWIGPERL %typemap(in) (const svn_delta_editor_t *EDITOR, void *BATON) { svn_delta_make_editor(&$1, &$2, $input, _global_pool); } void svn_delta_wrap_window_handler(svn_txdelta_window_handler_t *handler, void **handler_baton, SV *callback, apr_pool_t *pool); #endif #ifdef SWIGRUBY %typemap(in) (const svn_delta_editor_t *EDITOR, void *BATON) { if (RTEST(rb_obj_is_kind_of($input, svn_swig_rb_svn_delta_editor()))) { $1 = svn_swig_rb_to_swig_type($input, "svn_delta_editor_t *", _global_pool); $2 = svn_swig_rb_to_swig_type(rb_funcall($input, rb_intern("baton"), 0), "void *", _global_pool); } else { svn_swig_rb_make_delta_editor(&$1, &$2, $input, _global_pool); } } #endif #ifndef SWIGPYTHON /* Python users have to use svn_swig_py_make_editor manually, which sucks. Maybe we could allow people to pass a python object in the editor parameter, and None as the baton, and automatically invoke svn_swig_py_make_editor, rather than forcing the svn_swig_py_make_editor to be done manually. Of course, ideally, the baton parameter would vanish from the python side entirely, but we can't kill compatibility like that until 2.0. */ %apply (const svn_delta_editor_t *EDITOR, void *BATON) { (const svn_delta_editor_t *editor, void *baton), (const svn_delta_editor_t *editor, void *edit_baton), (const svn_delta_editor_t *editor, void *file_baton), (const svn_delta_editor_t *diff_editor, void *diff_baton), (const svn_delta_editor_t *update_editor, void *update_baton), (const svn_delta_editor_t *switch_editor, void *switch_baton), (const svn_delta_editor_t *status_editor, void *status_baton) } #endif /* ----------------------------------------------------------------------- handle svn_txdelta_window_handler_t/baton pair. */ #ifdef SWIGRUBY %typemap(in) (svn_txdelta_window_handler_t handler, void *handler_baton) { if (RTEST(rb_obj_is_kind_of($input, svn_swig_rb_svn_delta_text_delta_window_handler()))) { $1 = svn_swig_rb_to_swig_type($input, "svn_txdelta_window_handler_t", _global_pool); $2 = svn_swig_rb_to_swig_type(rb_funcall($input, rb_intern("baton"), 0), "void *", _global_pool); } else { $1 = svn_swig_rb_txdelta_window_handler; $2 = (void *)svn_swig_rb_make_baton($input, _global_svn_swig_rb_pool); } } #endif /* ----------------------------------------------------------------------- handle svn_delta_path_driver(). */ #ifndef SWIGPERL %callback_typemap(svn_delta_path_driver_cb_func_t callback_func, void *callback_baton, svn_swig_py_delta_path_driver_cb_func, , svn_swig_rb_delta_path_driver_cb_func) #endif /* ----------------------------------------------------------------------- */ %{ #include #include "svn_md5.h" %} /* ----------------------------------------------------------------------- handle svn_txdelta_window_t::ops */ #ifdef SWIGRUBY %ignore svn_txdelta_window_t::ops; %inline %{ static VALUE svn_txdelta_window_t_ops_get(svn_txdelta_window_t *window) { return svn_swig_rb_txdelta_window_t_ops_get(window); } %} #endif #ifdef SWIGPYTHON %ignore svn_txdelta_window_t::ops; %extend svn_txdelta_window_t { void _ops_get(int *num_ops, svn_txdelta_op_t **ops) { *num_ops = self->num_ops; *ops = self->ops; } %pythoncode { ops = property(_ops_get) } } %typemap(argout) (int *num_ops, svn_txdelta_op_t **ops) { apr_pool_t *parent_pool; PyObject *parent_py_pool; PyObject *ops_list; if (svn_swig_py_get_parent_pool(args, $descriptor(apr_pool_t *), &parent_py_pool, &parent_pool)) SWIG_fail; ops_list = svn_swig_py_convert_txdelta_op_c_array(*$1, *$2, $descriptor(svn_txdelta_op_t *), parent_py_pool); if (!ops_list) SWIG_fail; %append_output(ops_list); } #endif %include svn_delta_h.swg #ifdef SWIGPYTHON %pythoncode { # This function is for backwards compatibility only. # Use svn_txdelta_window_t.ops instead. svn_txdelta_window_t_ops_get = svn_txdelta_window_t._ops_get } #endif #ifdef SWIGRUBY %inline %{ static VALUE svn_swig_rb_delta_editor_get_target_revision(VALUE editor) { static ID id_target_revision_address = 0; VALUE rb_target_address; svn_revnum_t *target_address; if (id_target_revision_address == 0) id_target_revision_address = rb_intern("@target_revision_address"); if (!RTEST(rb_ivar_defined(editor, id_target_revision_address))) return Qnil; rb_target_address = rb_ivar_get(editor, id_target_revision_address); if (NIL_P(rb_target_address)) return Qnil; target_address = (svn_revnum_t *)(NUM2LONG(rb_target_address)); if (!target_address) return Qnil; return LONG2NUM(*target_address); } %} #endif /* ----------------------------------------------------------------------- handle svn_txdelta_apply_instructions() */ #ifdef SWIGRUBY %inline %{ static VALUE svn_swig_rb_txdelta_apply_instructions(svn_txdelta_window_t *window, const char *sbuf) { char *tbuf; apr_size_t tlen; tlen = window->tview_len + 1; tbuf = ALLOCA_N(char, tlen); svn_txdelta_apply_instructions(window, sbuf, tbuf, &tlen); return rb_str_new(tbuf, tlen); } %} #endif /* ----------------------------------------------------------------------- handle svn_txdelta_to_svndiff(). */ #ifdef SWIGRUBY %inline %{ static void svn_txdelta_apply_wrapper(svn_stream_t *source, svn_stream_t *target, unsigned char *result_digest, const char *error_info, svn_txdelta_window_handler_t *handler, void **handler_baton, apr_pool_t *pool) { svn_txdelta_apply(source, target, result_digest, error_info, pool, handler, handler_baton); } static svn_error_t * svn_delta_editor_invoke_open_root_wrapper(svn_delta_editor_t *editor, void *edit_baton, svn_revnum_t base_revision, void **root_baton, apr_pool_t *dir_pool) { return svn_delta_editor_invoke_open_root(editor, edit_baton, base_revision, dir_pool, root_baton); } static svn_error_t * svn_delta_editor_invoke_add_directory_wrapper(svn_delta_editor_t *editor, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, void **child_baton, apr_pool_t *dir_pool) { return svn_delta_editor_invoke_add_directory(editor, path, parent_baton, copyfrom_path, copyfrom_revision, dir_pool, child_baton); } static svn_error_t * svn_delta_editor_invoke_open_directory_wrapper(svn_delta_editor_t *editor, const char *path, void *parent_baton, svn_revnum_t base_revision, void **child_baton, apr_pool_t *dir_pool) { return svn_delta_editor_invoke_open_directory(editor, path, parent_baton, base_revision, dir_pool, child_baton); } static svn_error_t * svn_delta_editor_invoke_add_file_wrapper(svn_delta_editor_t *editor, const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_revision, void **file_baton, apr_pool_t *file_pool) { return svn_delta_editor_invoke_add_file(editor, path, parent_baton, copyfrom_path, copyfrom_revision, file_pool, file_baton); } static svn_error_t * svn_delta_editor_invoke_open_file_wrapper(svn_delta_editor_t *editor, const char *path, void *parent_baton, svn_revnum_t base_revision, void **file_baton, apr_pool_t *file_pool) { return svn_delta_editor_invoke_open_file(editor, path, parent_baton, base_revision, file_pool, file_baton); } static svn_error_t * svn_delta_editor_invoke_apply_textdelta_wrapper(svn_delta_editor_t *editor, void *file_baton, const char *base_checksum, svn_txdelta_window_handler_t *handler, void **handler_baton, apr_pool_t *pool) { return svn_delta_editor_invoke_apply_textdelta(editor, file_baton, base_checksum, pool, handler, handler_baton); } static svn_error_t * svn_txdelta_invoke_window_handler_wrapper(VALUE obj, svn_txdelta_window_t *window, apr_pool_t *pool) { return svn_swig_rb_invoke_txdelta_window_handler_wrapper(obj, window, pool); } static svn_error_t * svn_txdelta_editor_invoke_apply_textdelta_wrapper(VALUE obj, svn_txdelta_window_t *window, apr_pool_t *pool) { return svn_swig_rb_invoke_txdelta_window_handler_wrapper(obj, window, pool); } static const char * svn_txdelta_md5_digest_as_cstring(svn_txdelta_stream_t *stream, apr_pool_t *pool) { const unsigned char *digest; digest = svn_txdelta_md5_digest(stream); if (digest) { return svn_md5_digest_to_cstring(digest, pool); } else { return NULL; } } %} #endif