del tmp files
This commit is contained in:
Anthony Li
parent
60da096a07
commit
d0b6a4bfc5
660 changed files with 0 additions and 180469 deletions
|
|
@ -1,9 +0,0 @@
|
|||
# Test import of modules content from within __init__.py
|
||||
print("Testing %module(package=...) + python 'import' in __init__.py")
|
||||
import sys
|
||||
if sys.version_info < (3, 0):
|
||||
import py2.pkg2.bar
|
||||
print(" Finished importing py2.pkg2.bar")
|
||||
else:
|
||||
import py3.pkg2.bar
|
||||
print(" Finished importing py3.pkg2.bar")
|
||||
|
|
@ -1,746 +0,0 @@
|
|||
#######################################################################
|
||||
# SWIG test suite makefile.
|
||||
# The test suite comprises many different test cases, which have
|
||||
# typically produced bugs in the past. The aim is to have the test
|
||||
# cases compiling for every language modules. Some testcase have
|
||||
# a runtime test which is written in each of the module's language.
|
||||
#
|
||||
# This makefile runs SWIG on the testcases, compiles the c/c++ code
|
||||
# then builds the object code for use by the language.
|
||||
# To complete a test in a language follow these guidelines:
|
||||
# 1) Add testcases to CPP_TEST_CASES (c++) or C_TEST_CASES (c) or
|
||||
# MULTI_CPP_TEST_CASES (multi-module c++ tests)
|
||||
# 2) If not already done, create a makefile which:
|
||||
# a) Defines LANGUAGE matching a language rule in Examples/Makefile,
|
||||
# for example LANGUAGE = java
|
||||
# b) Define rules for %.ctest, %.cpptest, %.multicpptest and %.clean.
|
||||
# c) Define srcdir, top_srcdir and top_builddir (these are the
|
||||
# equivalent to configure's variables of the same name).
|
||||
# 3) One off special commandline options for a testcase can be added.
|
||||
# See custom tests below.
|
||||
#
|
||||
# The 'check' target runs the testcases including SWIG invocation,
|
||||
# C/C++ compilation, target language compilation (if any) and runtime
|
||||
# test (if there is an associated 'runme' test).
|
||||
# The 'partialcheck' target only invokes SWIG.
|
||||
# The 'all' target is the same as the 'check' target but also includes
|
||||
# known broken testcases.
|
||||
# The 'clean' target cleans up.
|
||||
#
|
||||
# Note that the RUNTOOL, COMPILETOOL and SWIGTOOL variables can be used
|
||||
# for invoking tools for the runtime tests and target language
|
||||
# compiler (eg javac), and on SWIG respectively. For example, valgrind
|
||||
# can be used for memory checking of the runtime tests using:
|
||||
# make RUNTOOL="valgrind --leak-check=full"
|
||||
# and valgrind can be used when invoking SWIG using:
|
||||
# make SWIGTOOL="valgrind --tool=memcheck --trace-children=yes"
|
||||
# Note: trace-children needed because of preinst-swig shell wrapper
|
||||
# to the swig executable.
|
||||
#
|
||||
# An individual test run can be debugged easily:
|
||||
# make director_string.cpptest RUNTOOL="gdb --args"
|
||||
#
|
||||
# The variables below can be overridden after including this makefile
|
||||
#######################################################################
|
||||
|
||||
#######################################################################
|
||||
# Variables
|
||||
#######################################################################
|
||||
|
||||
ifneq (,$(USE_VALGRIND))
|
||||
VALGRIND_OPT = --leak-check=full
|
||||
RUNTOOL = valgrind $(VALGRIND_OPT)
|
||||
else
|
||||
RUNTOOL =
|
||||
endif
|
||||
COMPILETOOL=
|
||||
SWIGTOOL =
|
||||
|
||||
SWIG = $(SWIGTOOL) $(top_builddir)/preinst-swig
|
||||
SWIG_LIB = $(top_srcdir)/Lib
|
||||
TEST_SUITE = test-suite
|
||||
EXAMPLES = Examples
|
||||
CXXSRCS =
|
||||
CSRCS =
|
||||
TARGETPREFIX =
|
||||
TARGETSUFFIX =
|
||||
SWIGOPT = -outcurrentdir -I$(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)
|
||||
INCLUDES = -I$(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)
|
||||
LIBS = -L.
|
||||
LIBPREFIX = lib
|
||||
ACTION = check
|
||||
INTERFACEDIR = ../
|
||||
SRCDIR = $(srcdir)/
|
||||
SCRIPTDIR = $(srcdir)
|
||||
|
||||
# Regenerate Makefile if Makefile.in or config.status have changed.
|
||||
Makefile: $(srcdir)/Makefile.in ../../../config.status
|
||||
cd ../../../ && $(SHELL) ./config.status $(EXAMPLES)/$(TEST_SUITE)/$(LANGUAGE)/Makefile
|
||||
|
||||
#
|
||||
# Please keep test cases in alphabetical order.
|
||||
# Note that any whitespace after the last entry in each list will break make
|
||||
#
|
||||
|
||||
# Broken C++ test cases. (Can be run individually using: make testcase.cpptest)
|
||||
CPP_TEST_BROKEN += \
|
||||
constants \
|
||||
cpp_broken \
|
||||
exception_partial_info \
|
||||
extend_variable \
|
||||
li_std_vector_ptr \
|
||||
li_boost_shared_ptr_template \
|
||||
nested_private \
|
||||
overload_complicated \
|
||||
rename_camel \
|
||||
template_default_pointer \
|
||||
template_private_assignment \
|
||||
template_expr \
|
||||
$(CPP11_TEST_BROKEN)
|
||||
|
||||
|
||||
# Broken C test cases. (Can be run individually using: make testcase.ctest)
|
||||
C_TEST_BROKEN += \
|
||||
tag_no_clash_with_variable
|
||||
|
||||
# C++ test cases. (Can be run individually using: make testcase.cpptest)
|
||||
CPP_TEST_CASES += \
|
||||
abstract_access \
|
||||
abstract_inherit \
|
||||
abstract_inherit_ok \
|
||||
abstract_signature \
|
||||
abstract_typedef \
|
||||
abstract_typedef2 \
|
||||
abstract_virtual \
|
||||
access_change \
|
||||
add_link \
|
||||
aggregate \
|
||||
allowexcept \
|
||||
allprotected \
|
||||
allprotected_not \
|
||||
anonymous_bitfield \
|
||||
apply_signed_char \
|
||||
apply_strings \
|
||||
argout \
|
||||
array_member \
|
||||
array_typedef_memberin \
|
||||
arrayref \
|
||||
arrays_dimensionless \
|
||||
arrays_global \
|
||||
arrays_global_twodim \
|
||||
arrays_scope \
|
||||
autodoc \
|
||||
bloody_hell \
|
||||
bools \
|
||||
catches \
|
||||
cast_operator \
|
||||
casts \
|
||||
char_binary \
|
||||
char_strings \
|
||||
class_forward \
|
||||
class_ignore \
|
||||
class_scope_weird \
|
||||
compactdefaultargs \
|
||||
const_const_2 \
|
||||
constant_pointers \
|
||||
constover \
|
||||
constructor_copy \
|
||||
constructor_exception \
|
||||
constructor_explicit \
|
||||
constructor_ignore \
|
||||
constructor_rename \
|
||||
constructor_value \
|
||||
contract \
|
||||
conversion \
|
||||
conversion_namespace \
|
||||
conversion_ns_template \
|
||||
cplusplus_throw \
|
||||
cpp_basic \
|
||||
cpp_enum \
|
||||
cpp_namespace \
|
||||
cpp_nodefault \
|
||||
cpp_static \
|
||||
cpp_typedef \
|
||||
curiously_recurring_template_pattern \
|
||||
default_args \
|
||||
default_arg_values \
|
||||
default_constructor \
|
||||
defvalue_constructor \
|
||||
derived_byvalue \
|
||||
derived_nested \
|
||||
destructor_reprotected \
|
||||
director_abstract \
|
||||
director_alternating \
|
||||
director_basic \
|
||||
director_binary_string \
|
||||
director_classes \
|
||||
director_classic \
|
||||
director_constructor \
|
||||
director_default \
|
||||
director_detect \
|
||||
director_enum \
|
||||
director_exception \
|
||||
director_extend \
|
||||
director_finalizer \
|
||||
director_frob \
|
||||
director_ignore \
|
||||
director_keywords \
|
||||
director_namespace_clash \
|
||||
director_nspace \
|
||||
director_nspace_director_name_collision \
|
||||
director_nested \
|
||||
director_overload \
|
||||
director_overload2 \
|
||||
director_primitives \
|
||||
director_protected \
|
||||
director_protected_overloaded \
|
||||
director_redefined \
|
||||
director_smartptr \
|
||||
director_thread \
|
||||
director_unroll \
|
||||
director_using \
|
||||
director_wombat \
|
||||
disown \
|
||||
dynamic_cast \
|
||||
empty \
|
||||
enum_ignore \
|
||||
enum_plus \
|
||||
enum_rename \
|
||||
enum_scope_template \
|
||||
enum_template \
|
||||
enum_thorough \
|
||||
enum_var \
|
||||
equality \
|
||||
evil_diamond \
|
||||
evil_diamond_ns \
|
||||
evil_diamond_prop \
|
||||
exception_order \
|
||||
extend \
|
||||
extend_constructor_destructor \
|
||||
extend_default \
|
||||
extend_placement \
|
||||
extend_special_variables \
|
||||
extend_template \
|
||||
extend_template_ns \
|
||||
extend_typedef_class \
|
||||
extern_c \
|
||||
extern_namespace \
|
||||
extern_throws \
|
||||
expressions \
|
||||
features \
|
||||
fragments \
|
||||
friends \
|
||||
funcptr_cpp \
|
||||
fvirtual \
|
||||
global_namespace \
|
||||
global_ns_arg \
|
||||
global_scope_types \
|
||||
global_vars \
|
||||
grouping \
|
||||
ignore_parameter \
|
||||
import_nomodule \
|
||||
inherit \
|
||||
inherit_missing \
|
||||
inherit_same_name \
|
||||
inherit_target_language \
|
||||
inherit_void_arg \
|
||||
inline_initializer \
|
||||
insert_directive \
|
||||
keyword_rename \
|
||||
kind \
|
||||
langobj \
|
||||
li_attribute \
|
||||
li_attribute_template \
|
||||
li_boost_shared_ptr \
|
||||
li_boost_shared_ptr_bits \
|
||||
li_boost_shared_ptr_template \
|
||||
li_boost_shared_ptr_attribute \
|
||||
li_carrays \
|
||||
li_cdata \
|
||||
li_cpointer \
|
||||
li_std_auto_ptr \
|
||||
li_stdint \
|
||||
li_swigtype_inout \
|
||||
li_typemaps \
|
||||
li_typemaps_apply \
|
||||
li_windows \
|
||||
long_long_apply \
|
||||
memberin_extend \
|
||||
member_funcptr_galore \
|
||||
member_pointer \
|
||||
member_template \
|
||||
minherit \
|
||||
minherit2 \
|
||||
mixed_types \
|
||||
multiple_inheritance \
|
||||
name_cxx \
|
||||
name_warnings \
|
||||
namespace_class \
|
||||
namespace_enum \
|
||||
namespace_extend \
|
||||
namespace_forward_declaration \
|
||||
namespace_nested \
|
||||
namespace_spaces \
|
||||
namespace_template \
|
||||
namespace_typedef_class \
|
||||
namespace_typemap \
|
||||
namespace_union \
|
||||
namespace_virtual_method \
|
||||
nspace \
|
||||
nspace_extend \
|
||||
naturalvar \
|
||||
naturalvar_more \
|
||||
naturalvar_onoff \
|
||||
nested_class \
|
||||
nested_directors \
|
||||
nested_comment \
|
||||
nested_scope \
|
||||
nested_workaround \
|
||||
newobject1 \
|
||||
null_pointer \
|
||||
operator_overload \
|
||||
operator_overload_break \
|
||||
operator_pointer_ref \
|
||||
operbool \
|
||||
ordering \
|
||||
overload_bool \
|
||||
overload_copy \
|
||||
overload_extend \
|
||||
overload_method \
|
||||
overload_numeric \
|
||||
overload_rename \
|
||||
overload_return_type \
|
||||
overload_simple \
|
||||
overload_subtype \
|
||||
overload_template \
|
||||
overload_template_fast \
|
||||
pointer_reference \
|
||||
preproc_constants \
|
||||
primitive_ref \
|
||||
private_assign \
|
||||
protected_rename \
|
||||
pure_virtual \
|
||||
redefined \
|
||||
redefined_not \
|
||||
refcount \
|
||||
reference_global_vars \
|
||||
register_par \
|
||||
rename1 \
|
||||
rename2 \
|
||||
rename3 \
|
||||
rename4 \
|
||||
rename_scope \
|
||||
rename_simple \
|
||||
rename_strip_encoder \
|
||||
rename_pcre_encoder \
|
||||
rename_pcre_enum \
|
||||
rename_predicates \
|
||||
restrict_cplusplus \
|
||||
return_const_value \
|
||||
return_value_scope \
|
||||
rname \
|
||||
samename \
|
||||
sizet \
|
||||
smart_pointer_const \
|
||||
smart_pointer_const2 \
|
||||
smart_pointer_const_overload \
|
||||
smart_pointer_extend \
|
||||
smart_pointer_member \
|
||||
smart_pointer_multi \
|
||||
smart_pointer_multi_typedef \
|
||||
smart_pointer_namespace \
|
||||
smart_pointer_namespace2 \
|
||||
smart_pointer_not \
|
||||
smart_pointer_overload \
|
||||
smart_pointer_protected \
|
||||
smart_pointer_rename \
|
||||
smart_pointer_simple \
|
||||
smart_pointer_static \
|
||||
smart_pointer_template_const_overload \
|
||||
smart_pointer_template_defaults_overload \
|
||||
smart_pointer_templatemethods \
|
||||
smart_pointer_templatevariables \
|
||||
smart_pointer_typedef \
|
||||
special_variables \
|
||||
special_variable_macros \
|
||||
static_array_member \
|
||||
static_const_member \
|
||||
static_const_member_2 \
|
||||
struct_initialization_cpp \
|
||||
struct_value \
|
||||
symbol_clash \
|
||||
template_arg_replace \
|
||||
template_arg_scope \
|
||||
template_arg_typename \
|
||||
template_array_numeric \
|
||||
template_basic \
|
||||
template_base_template \
|
||||
template_classes \
|
||||
template_const_ref \
|
||||
template_construct \
|
||||
template_default \
|
||||
template_default2 \
|
||||
template_default_arg \
|
||||
template_default_arg_virtual_destructor \
|
||||
template_default_class_parms \
|
||||
template_default_class_parms_typedef \
|
||||
template_default_inherit \
|
||||
template_default_qualify \
|
||||
template_default_vw \
|
||||
template_enum \
|
||||
template_enum_ns_inherit \
|
||||
template_enum_typedef \
|
||||
template_explicit \
|
||||
template_extend1 \
|
||||
template_extend2 \
|
||||
template_extend_overload \
|
||||
template_extend_overload_2 \
|
||||
template_forward \
|
||||
template_inherit \
|
||||
template_inherit_abstract \
|
||||
template_int_const \
|
||||
template_methods \
|
||||
template_namespace_forward_declaration \
|
||||
template_using_directive_and_declaration_forward \
|
||||
template_nested \
|
||||
template_nested_typemaps \
|
||||
template_ns \
|
||||
template_ns2 \
|
||||
template_ns3 \
|
||||
template_ns4 \
|
||||
template_ns_enum \
|
||||
template_ns_enum2 \
|
||||
template_ns_inherit \
|
||||
template_ns_scope \
|
||||
template_partial_arg \
|
||||
template_partial_specialization \
|
||||
template_partial_specialization_typedef \
|
||||
template_qualifier \
|
||||
template_ref_type \
|
||||
template_rename \
|
||||
template_retvalue \
|
||||
template_specialization \
|
||||
template_specialization_defarg \
|
||||
template_specialization_enum \
|
||||
template_static \
|
||||
template_tbase_template \
|
||||
template_template_parameters \
|
||||
template_typedef \
|
||||
template_typedef_class_template \
|
||||
template_typedef_cplx \
|
||||
template_typedef_cplx2 \
|
||||
template_typedef_cplx3 \
|
||||
template_typedef_cplx4 \
|
||||
template_typedef_cplx5 \
|
||||
template_typedef_funcptr \
|
||||
template_typedef_inherit \
|
||||
template_typedef_ns \
|
||||
template_typedef_ptr \
|
||||
template_typedef_rec \
|
||||
template_typedef_typedef \
|
||||
template_typemaps \
|
||||
template_typemaps_typedef \
|
||||
template_typemaps_typedef2 \
|
||||
template_using \
|
||||
template_virtual \
|
||||
template_whitespace \
|
||||
threads \
|
||||
threads_exception \
|
||||
throw_exception \
|
||||
typedef_array_member \
|
||||
typedef_class \
|
||||
typedef_funcptr \
|
||||
typedef_inherit \
|
||||
typedef_mptr \
|
||||
typedef_reference \
|
||||
typedef_scope \
|
||||
typedef_sizet \
|
||||
typedef_struct \
|
||||
typedef_typedef \
|
||||
typemap_arrays \
|
||||
typemap_array_qualifiers \
|
||||
typemap_delete \
|
||||
typemap_directorout \
|
||||
typemap_global_scope \
|
||||
typemap_manyargs \
|
||||
typemap_namespace \
|
||||
typemap_ns_using \
|
||||
typemap_numinputs \
|
||||
typemap_template \
|
||||
typemap_template_parm_typedef \
|
||||
typemap_out_optimal \
|
||||
typemap_qualifier_strip \
|
||||
typemap_variables \
|
||||
typemap_various \
|
||||
typename \
|
||||
types_directive \
|
||||
unicode_strings \
|
||||
union_scope \
|
||||
using1 \
|
||||
using2 \
|
||||
using_composition \
|
||||
using_directive_and_declaration \
|
||||
using_directive_and_declaration_forward \
|
||||
using_extend \
|
||||
using_inherit \
|
||||
using_namespace \
|
||||
using_namespace_loop \
|
||||
using_pointers \
|
||||
using_private \
|
||||
using_protected \
|
||||
valuewrapper \
|
||||
valuewrapper_base \
|
||||
valuewrapper_const \
|
||||
valuewrapper_opaque \
|
||||
varargs \
|
||||
varargs_overload \
|
||||
virtual_destructor \
|
||||
virtual_poly \
|
||||
virtual_vs_nonvirtual_base \
|
||||
voidtest \
|
||||
wallkw \
|
||||
wrapmacro
|
||||
|
||||
# C++11 test cases.
|
||||
CPP11_TEST_CASES = \
|
||||
cpp11_alignment \
|
||||
cpp11_alternate_function_syntax \
|
||||
cpp11_constexpr \
|
||||
cpp11_decltype \
|
||||
cpp11_default_delete \
|
||||
cpp11_delegating_constructors \
|
||||
cpp11_explicit_conversion_operators \
|
||||
cpp11_final_override \
|
||||
cpp11_function_objects \
|
||||
cpp11_inheriting_constructors \
|
||||
cpp11_initializer_list \
|
||||
cpp11_initializer_list_extend \
|
||||
cpp11_lambda_functions \
|
||||
cpp11_noexcept \
|
||||
cpp11_null_pointer_constant \
|
||||
cpp11_raw_string_literals \
|
||||
cpp11_result_of \
|
||||
cpp11_rvalue_reference \
|
||||
cpp11_rvalue_reference2 \
|
||||
cpp11_rvalue_reference3 \
|
||||
cpp11_sizeof_object \
|
||||
cpp11_static_assert \
|
||||
cpp11_thread_local \
|
||||
cpp11_template_double_brackets \
|
||||
cpp11_template_explicit \
|
||||
cpp11_template_typedefs \
|
||||
cpp11_type_traits \
|
||||
cpp11_uniform_initialization \
|
||||
cpp11_unrestricted_unions \
|
||||
cpp11_userdefined_literals \
|
||||
|
||||
# Broken C++11 test cases.
|
||||
CPP11_TEST_BROKEN = \
|
||||
# cpp11_hash_tables \ # not fully implemented yet
|
||||
# cpp11_strongly_typed_enumerations \ # SWIG not quite getting this right yet in all langs
|
||||
# cpp11_variadic_templates \ # Broken for some languages (such as Java)
|
||||
# cpp11_reference_wrapper \ # No typemaps
|
||||
|
||||
|
||||
#
|
||||
# Put all the heavy STD/STL cases here, where they can be skipped if needed
|
||||
#
|
||||
CPP_STD_TEST_CASES += \
|
||||
director_string \
|
||||
ignore_template_constructor \
|
||||
li_std_combinations \
|
||||
li_std_deque \
|
||||
li_std_except \
|
||||
li_std_except_as_class \
|
||||
li_std_map \
|
||||
li_std_pair \
|
||||
li_std_pair_using \
|
||||
li_std_string \
|
||||
li_std_vector \
|
||||
li_std_vector_enum \
|
||||
li_std_vector_member_var\
|
||||
naturalvar \
|
||||
smart_pointer_inherit \
|
||||
template_typedef_fnc \
|
||||
template_type_namespace \
|
||||
template_opaque
|
||||
# li_std_list
|
||||
|
||||
|
||||
ifndef SKIP_CPP_STD_CASES
|
||||
CPP_TEST_CASES += ${CPP_STD_TEST_CASES}
|
||||
endif
|
||||
|
||||
ifneq (,$(HAVE_CXX11_COMPILER))
|
||||
CPP_TEST_CASES += $(CPP11_TEST_CASES)
|
||||
endif
|
||||
|
||||
# C test cases. (Can be run individually using: make testcase.ctest)
|
||||
C_TEST_CASES += \
|
||||
arrays \
|
||||
bom_utf8 \
|
||||
c_delete \
|
||||
c_delete_function \
|
||||
char_constant \
|
||||
const_const \
|
||||
constant_expr \
|
||||
empty \
|
||||
enums \
|
||||
enum_forward \
|
||||
enum_macro \
|
||||
enum_missing \
|
||||
extern_declaration \
|
||||
funcptr \
|
||||
function_typedef \
|
||||
global_functions \
|
||||
immutable_values \
|
||||
inctest \
|
||||
infinity \
|
||||
integers \
|
||||
keyword_rename \
|
||||
lextype \
|
||||
li_carrays \
|
||||
li_cdata \
|
||||
li_cmalloc \
|
||||
li_constraints \
|
||||
li_cpointer \
|
||||
li_math \
|
||||
long_long \
|
||||
memberin_extend_c \
|
||||
name \
|
||||
nested \
|
||||
nested_extend_c \
|
||||
nested_structs \
|
||||
newobject2 \
|
||||
overload_extend \
|
||||
overload_extendc \
|
||||
preproc \
|
||||
preproc_constants_c \
|
||||
preproc_defined \
|
||||
preproc_include \
|
||||
preproc_line_file \
|
||||
ret_by_value \
|
||||
simple_array \
|
||||
sizeof_pointer \
|
||||
sneaky1 \
|
||||
string_simple \
|
||||
struct_rename \
|
||||
struct_initialization \
|
||||
typedef_struct \
|
||||
typemap_subst \
|
||||
union_parameter \
|
||||
unions
|
||||
|
||||
|
||||
# Multi-module C++ test cases . (Can be run individually using make testcase.multicpptest)
|
||||
MULTI_CPP_TEST_CASES += \
|
||||
clientdata_prop \
|
||||
imports \
|
||||
import_stl \
|
||||
packageoption \
|
||||
mod \
|
||||
template_typedef_import \
|
||||
multi_import
|
||||
|
||||
# Custom tests - tests with additional commandline options
|
||||
wallkw.cpptest: SWIGOPT += -Wallkw
|
||||
preproc_include.ctest: SWIGOPT += -includeall
|
||||
|
||||
|
||||
NOT_BROKEN_TEST_CASES = $(CPP_TEST_CASES:=.cpptest) \
|
||||
$(C_TEST_CASES:=.ctest) \
|
||||
$(MULTI_CPP_TEST_CASES:=.multicpptest) \
|
||||
$(EXTRA_TEST_CASES)
|
||||
|
||||
BROKEN_TEST_CASES = $(CPP_TEST_BROKEN:=.cpptest) \
|
||||
$(C_TEST_BROKEN:=.ctest)
|
||||
|
||||
ALL_CLEAN = $(CPP_TEST_CASES:=.clean) \
|
||||
$(C_TEST_CASES:=.clean) \
|
||||
$(MULTI_CPP_TEST_CASES:=.clean) \
|
||||
$(CPP_TEST_BROKEN:=.clean) \
|
||||
$(C_TEST_BROKEN:=.clean)
|
||||
|
||||
#######################################################################
|
||||
# Error test suite has its own set of test cases
|
||||
#######################################################################
|
||||
ifneq (,$(ERROR_TEST_CASES))
|
||||
check: $(ERROR_TEST_CASES)
|
||||
else
|
||||
|
||||
#######################################################################
|
||||
# The following applies for all module languages
|
||||
#######################################################################
|
||||
all: $(NOT_BROKEN_TEST_CASES) $(BROKEN_TEST_CASES)
|
||||
|
||||
broken: $(BROKEN_TEST_CASES)
|
||||
|
||||
check: $(NOT_BROKEN_TEST_CASES)
|
||||
|
||||
check-c: $(C_TEST_CASES:=.ctest)
|
||||
|
||||
check-cpp: $(CPP_TEST_CASES:=.cpptest)
|
||||
|
||||
check-cpp11: $(CPP11_TEST_CASES:=.cpptest)
|
||||
|
||||
endif
|
||||
|
||||
# partialcheck target runs SWIG only, ie no compilation or running of tests (for a subset of languages)
|
||||
partialcheck:
|
||||
$(MAKE) check CC=true CXX=true LDSHARED=true CXXSHARED=true RUNTOOL=true COMPILETOOL=true
|
||||
|
||||
swig_and_compile_cpp = \
|
||||
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" CXXSRCS="$(CXXSRCS)" \
|
||||
SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
|
||||
INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
|
||||
TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
|
||||
$(LANGUAGE)$(VARIANT)_cpp
|
||||
|
||||
swig_and_compile_c = \
|
||||
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" CSRCS="$(CSRCS)" \
|
||||
SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
|
||||
INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
|
||||
TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
|
||||
$(LANGUAGE)$(VARIANT)
|
||||
|
||||
swig_and_compile_multi_cpp = \
|
||||
for f in `cat $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list` ; do \
|
||||
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" CXXSRCS="$(CXXSRCS)" \
|
||||
SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" LIBS='$(LIBS)' \
|
||||
INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
|
||||
TARGET="$(TARGETPREFIX)$${f}$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$$f.i" \
|
||||
$(LANGUAGE)$(VARIANT)_cpp; \
|
||||
done
|
||||
|
||||
swig_and_compile_external = \
|
||||
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" \
|
||||
SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
|
||||
TARGET="$*_wrap_hdr.h" \
|
||||
$(LANGUAGE)$(VARIANT)_externalhdr; \
|
||||
$(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" CXXSRCS="$(CXXSRCS) $*_external.cxx" \
|
||||
SWIG_LIB="$(SWIG_LIB)" SWIG="$(SWIG)" \
|
||||
INCLUDES="$(INCLUDES)" SWIGOPT="$(SWIGOPT)" NOLINK=true \
|
||||
TARGET="$(TARGETPREFIX)$*$(TARGETSUFFIX)" INTERFACEDIR="$(INTERFACEDIR)" INTERFACE="$*.i" \
|
||||
$(LANGUAGE)$(VARIANT)_cpp
|
||||
|
||||
swig_and_compile_runtime = \
|
||||
|
||||
setup = \
|
||||
if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \
|
||||
echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test)" ; \
|
||||
else \
|
||||
echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \
|
||||
fi;
|
||||
|
||||
|
||||
|
||||
#######################################################################
|
||||
# Clean
|
||||
#######################################################################
|
||||
clean: $(ALL_CLEAN)
|
||||
|
||||
distclean: clean
|
||||
@rm -f Makefile
|
||||
|
||||
.PHONY: all check partialcheck broken clean distclean
|
||||
|
||||
|
|
@ -1,311 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_access.i
|
||||
|
||||
package abstract_access
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_A_z unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_z(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_z, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Z() (_swig_ret int) {
|
||||
return _swig_wrap_A_z(arg1)
|
||||
}
|
||||
|
||||
var _wrap_A_do_x unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_do_x(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_do_x, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Do_x() (_swig_ret int) {
|
||||
return _swig_wrap_A_do_x(arg1)
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Z() (_swig_ret int)
|
||||
Do_x() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_B_z unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_z(base SwigcptrB) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_z, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrB) Z() (_swig_ret int) {
|
||||
return _swig_wrap_B_z(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_B_do_x unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_do_x(base SwigcptrB) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_do_x, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrB) Do_x() (_swig_ret int) {
|
||||
return _swig_wrap_B_do_x(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
Z() (_swig_ret int)
|
||||
Do_x() (_swig_ret int)
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_C_z unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_z(base SwigcptrC) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_z, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrC) Z() (_swig_ret int) {
|
||||
return _swig_wrap_C_z(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_C_do_x unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_do_x(base SwigcptrC) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_do_x, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrC) Do_x() (_swig_ret int) {
|
||||
return _swig_wrap_C_do_x(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetB() B {
|
||||
return SwigcptrB(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
Z() (_swig_ret int)
|
||||
Do_x() (_swig_ret int)
|
||||
SwigIsB()
|
||||
SwigGetB() B
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_new_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_D() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewD() (_swig_ret D) {
|
||||
return _swig_wrap_new_D()
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_D_z unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_z(base SwigcptrD) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_z, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrD) Z() (_swig_ret int) {
|
||||
return _swig_wrap_D_z(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_D_do_x unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_do_x(base SwigcptrD) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_do_x, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrD) Do_x() (_swig_ret int) {
|
||||
return _swig_wrap_D_do_x(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsC() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetC() C {
|
||||
return SwigcptrC(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetB() B {
|
||||
return SwigcptrB(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
Z() (_swig_ret int)
|
||||
Do_x() (_swig_ret int)
|
||||
SwigIsC()
|
||||
SwigGetC() C
|
||||
SwigIsB()
|
||||
SwigGetB() B
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,285 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_inherit.i
|
||||
|
||||
package abstract_inherit
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_blah(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Blah() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_blah(arg1)
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Blah() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_blah(base SwigcptrBar) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrBar) Blah() (_swig_ret int) {
|
||||
return _swig_wrap_Bar_blah(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
Blah() (_swig_ret int)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
type SwigcptrSpam uintptr
|
||||
|
||||
func (p SwigcptrSpam) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigIsSpam() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Spam(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSpam(arg1 Spam) {
|
||||
_swig_wrap_delete_Spam(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Spam_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Spam_blah(base SwigcptrSpam) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Spam_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrSpam) Blah() (_swig_ret int) {
|
||||
return _swig_wrap_Spam_blah(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Spam interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSpam()
|
||||
Blah() (_swig_ret int)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
type SwigcptrNRFilter_i uintptr
|
||||
|
||||
func (p SwigcptrNRFilter_i) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrNRFilter_i) SwigIsNRFilter_i() {
|
||||
}
|
||||
|
||||
var _wrap_delete_NRFilter_i unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_NRFilter_i(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_NRFilter_i, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteNRFilter_i(arg1 NRFilter_i) {
|
||||
_swig_wrap_delete_NRFilter_i(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type NRFilter_i interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsNRFilter_i()
|
||||
}
|
||||
|
||||
type SwigcptrNRRCFilter_i uintptr
|
||||
|
||||
func (p SwigcptrNRRCFilter_i) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrNRRCFilter_i) SwigIsNRRCFilter_i() {
|
||||
}
|
||||
|
||||
var _wrap_delete_NRRCFilter_i unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_NRRCFilter_i(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_NRRCFilter_i, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteNRRCFilter_i(arg1 NRRCFilter_i) {
|
||||
_swig_wrap_delete_NRRCFilter_i(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrNRRCFilter_i) SwigIsNRFilter_i() {
|
||||
}
|
||||
|
||||
func (p SwigcptrNRRCFilter_i) SwigGetNRFilter_i() NRFilter_i {
|
||||
return SwigcptrNRFilter_i(p.Swigcptr())
|
||||
}
|
||||
|
||||
type NRRCFilter_i interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsNRRCFilter_i()
|
||||
SwigIsNRFilter_i()
|
||||
SwigGetNRFilter_i() NRFilter_i
|
||||
}
|
||||
|
||||
type SwigcptrNRRCFilterpro_i uintptr
|
||||
|
||||
func (p SwigcptrNRRCFilterpro_i) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrNRRCFilterpro_i) SwigIsNRRCFilterpro_i() {
|
||||
}
|
||||
|
||||
var _wrap_delete_NRRCFilterpro_i unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_NRRCFilterpro_i(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_NRRCFilterpro_i, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteNRRCFilterpro_i(arg1 NRRCFilterpro_i) {
|
||||
_swig_wrap_delete_NRRCFilterpro_i(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type NRRCFilterpro_i interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsNRRCFilterpro_i()
|
||||
}
|
||||
|
||||
type SwigcptrNRRCFilterpri_i uintptr
|
||||
|
||||
func (p SwigcptrNRRCFilterpri_i) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrNRRCFilterpri_i) SwigIsNRRCFilterpri_i() {
|
||||
}
|
||||
|
||||
var _wrap_delete_NRRCFilterpri_i unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_NRRCFilterpri_i(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_NRRCFilterpri_i, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteNRRCFilterpri_i(arg1 NRRCFilterpri_i) {
|
||||
_swig_wrap_delete_NRRCFilterpri_i(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type NRRCFilterpri_i interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsNRRCFilterpri_i()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,136 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_inherit_ok.i
|
||||
|
||||
package abstract_inherit_ok
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_blah(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Blah() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_blah(arg1)
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Blah() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrSpam uintptr
|
||||
|
||||
func (p SwigcptrSpam) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigIsSpam() {
|
||||
}
|
||||
|
||||
var _wrap_new_Spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Spam() (base SwigcptrSpam) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSpam() (_swig_ret Spam) {
|
||||
return _swig_wrap_new_Spam()
|
||||
}
|
||||
|
||||
var _wrap_delete_Spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Spam(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSpam(arg1 Spam) {
|
||||
_swig_wrap_delete_Spam(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Spam_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Spam_blah(base SwigcptrSpam) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Spam_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrSpam) Blah() (_swig_ret int) {
|
||||
return _swig_wrap_Spam_blah(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Spam interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSpam()
|
||||
Blah() (_swig_ret int)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,147 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_signature.i
|
||||
|
||||
package abstract_signature
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrAbstract_foo uintptr
|
||||
|
||||
func (p SwigcptrAbstract_foo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstract_foo) SwigIsAbstract_foo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_abstract_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_abstract_foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_abstract_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAbstract_foo(arg1 Abstract_foo) {
|
||||
_swig_wrap_delete_abstract_foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_abstract_foo_meth unsafe.Pointer
|
||||
|
||||
func _swig_wrap_abstract_foo_meth(base SwigcptrAbstract_foo, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_abstract_foo_meth, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAbstract_foo) Meth(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_abstract_foo_meth(arg1, arg2)
|
||||
}
|
||||
|
||||
type Abstract_foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAbstract_foo()
|
||||
Meth(arg2 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrAbstract_bar uintptr
|
||||
|
||||
func (p SwigcptrAbstract_bar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstract_bar) SwigIsAbstract_bar() {
|
||||
}
|
||||
|
||||
var _wrap_delete_abstract_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_abstract_bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_abstract_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAbstract_bar(arg1 Abstract_bar) {
|
||||
_swig_wrap_delete_abstract_bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_abstract_bar_meth__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_abstract_bar_meth__SWIG_0(base SwigcptrAbstract_bar, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_abstract_bar_meth__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAbstract_bar) Meth__SWIG_0(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_abstract_bar_meth__SWIG_0(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_abstract_bar_meth__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_abstract_bar_meth__SWIG_1(base SwigcptrAbstract_bar, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_abstract_bar_meth__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAbstract_bar) Meth__SWIG_1(arg2 int, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_abstract_bar_meth__SWIG_1(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstract_bar) Meth(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 1 {
|
||||
return p.Meth__SWIG_0(a[0].(int))
|
||||
}
|
||||
if argc == 2 {
|
||||
return p.Meth__SWIG_1(a[0].(int), a[1].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstract_bar) SwigIsAbstract_foo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstract_bar) SwigGetAbstract_foo() Abstract_foo {
|
||||
return SwigcptrAbstract_foo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Abstract_bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAbstract_bar()
|
||||
Meth(a ...interface{}) int
|
||||
SwigIsAbstract_foo()
|
||||
SwigGetAbstract_foo() Abstract_foo
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,174 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_typedef.i
|
||||
|
||||
package abstract_typedef
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrEngine uintptr
|
||||
|
||||
func (p SwigcptrEngine) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrEngine) SwigIsEngine() {
|
||||
}
|
||||
|
||||
var _wrap_new_Engine unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Engine() (base SwigcptrEngine) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Engine, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewEngine() (_swig_ret Engine) {
|
||||
return _swig_wrap_new_Engine()
|
||||
}
|
||||
|
||||
var _wrap_delete_Engine unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Engine(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Engine, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteEngine(arg1 Engine) {
|
||||
_swig_wrap_delete_Engine(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Engine interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsEngine()
|
||||
}
|
||||
|
||||
type SwigcptrAbstractBaseClass uintptr
|
||||
|
||||
func (p SwigcptrAbstractBaseClass) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAbstractBaseClass) SwigIsAbstractBaseClass() {
|
||||
}
|
||||
|
||||
var _wrap_delete_AbstractBaseClass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_AbstractBaseClass(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_AbstractBaseClass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAbstractBaseClass(arg1 AbstractBaseClass) {
|
||||
_swig_wrap_delete_AbstractBaseClass(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_AbstractBaseClass_write unsafe.Pointer
|
||||
|
||||
func _swig_wrap_AbstractBaseClass_write(base SwigcptrAbstractBaseClass, _ uintptr) (_ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_AbstractBaseClass_write, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAbstractBaseClass) Write(arg2 Engine) (_swig_ret bool) {
|
||||
return _swig_wrap_AbstractBaseClass_write(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
type AbstractBaseClass interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAbstractBaseClass()
|
||||
Write(arg2 Engine) (_swig_ret bool)
|
||||
}
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_A_write unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_write(base SwigcptrA, _ uintptr) (_ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_write, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrA) Write(arg1 Engine) (_swig_ret bool) {
|
||||
return _swig_wrap_A_write(_swig_base, arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsAbstractBaseClass() {
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigGetAbstractBaseClass() AbstractBaseClass {
|
||||
return SwigcptrAbstractBaseClass(p.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Write(arg1 Engine) (_swig_ret bool)
|
||||
SwigIsAbstractBaseClass()
|
||||
SwigGetAbstractBaseClass() AbstractBaseClass
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,184 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_typedef2.i
|
||||
|
||||
package abstract_typedef2
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type FieldDim int
|
||||
var _wrap_UnaryField unsafe.Pointer
|
||||
|
||||
func _swig_getUnaryField() (_swig_ret FieldDim) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_UnaryField, _swig_p)
|
||||
return
|
||||
}
|
||||
var UnaryField FieldDim = _swig_getUnaryField()
|
||||
var _wrap_BinaryField unsafe.Pointer
|
||||
|
||||
func _swig_getBinaryField() (_swig_ret FieldDim) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BinaryField, _swig_p)
|
||||
return
|
||||
}
|
||||
var BinaryField FieldDim = _swig_getBinaryField()
|
||||
type SwigcptrBase_UF uintptr
|
||||
|
||||
func (p SwigcptrBase_UF) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBase_UF) SwigIsBase_UF() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Base_UF unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Base_UF(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Base_UF, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBase_UF(arg1 Base_UF) {
|
||||
_swig_wrap_delete_Base_UF(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Base_UF_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Base_UF_set(base SwigcptrBase_UF, _ uint) (_ SwigcptrFacet_Sl_UnaryField_Sg_) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Base_UF_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBase_UF) Set(arg2 uint) (_swig_ret Facet_Sl_UnaryField_Sg_) {
|
||||
return _swig_wrap_Base_UF_set(arg1, arg2)
|
||||
}
|
||||
|
||||
type Base_UF interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBase_UF()
|
||||
Set(arg2 uint) (_swig_ret Facet_Sl_UnaryField_Sg_)
|
||||
}
|
||||
|
||||
type SwigcptrA_UF uintptr
|
||||
|
||||
func (p SwigcptrA_UF) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA_UF) SwigIsA_UF() {
|
||||
}
|
||||
|
||||
var _wrap_new_A_UF__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A_UF__SWIG_0(base int) (_ SwigcptrA_UF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A_UF__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA_UF__SWIG_0(arg1 int) (_swig_ret A_UF) {
|
||||
return _swig_wrap_new_A_UF__SWIG_0(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_A_UF__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A_UF__SWIG_1() (base SwigcptrA_UF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A_UF__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA_UF__SWIG_1() (_swig_ret A_UF) {
|
||||
return _swig_wrap_new_A_UF__SWIG_1()
|
||||
}
|
||||
|
||||
func NewA_UF(a ...interface{}) A_UF {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewA_UF__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewA_UF__SWIG_0(a[0].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_UF_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_UF_set(base SwigcptrA_UF, _ uint) (_ SwigcptrFacet_Sl_UnaryField_Sg_) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_UF_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA_UF) Set(arg2 uint) (_swig_ret Facet_Sl_UnaryField_Sg_) {
|
||||
return _swig_wrap_A_UF_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_A_UF unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A_UF(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A_UF, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA_UF(arg1 A_UF) {
|
||||
_swig_wrap_delete_A_UF(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrA_UF) SwigIsBase_UF() {
|
||||
}
|
||||
|
||||
func (p SwigcptrA_UF) SwigGetBase_UF() Base_UF {
|
||||
return SwigcptrBase_UF(p.Swigcptr())
|
||||
}
|
||||
|
||||
type A_UF interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA_UF()
|
||||
Set(arg2 uint) (_swig_ret Facet_Sl_UnaryField_Sg_)
|
||||
SwigIsBase_UF()
|
||||
SwigGetBase_UF() Base_UF
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrFacet_Sl_UnaryField_Sg_ uintptr
|
||||
type Facet_Sl_UnaryField_Sg_ interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrFacet_Sl_UnaryField_Sg_) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -1,348 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../abstract_virtual.i
|
||||
|
||||
package abstract_virtual
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_A_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_foo(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Foo() (_swig_ret int) {
|
||||
return _swig_wrap_A_foo(arg1)
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Foo() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_B_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_foo(base SwigcptrB) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrB) Foo() (_swig_ret int) {
|
||||
return _swig_wrap_B_foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B() (base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB() (_swig_ret B) {
|
||||
return _swig_wrap_new_B()
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
Foo() (_swig_ret int)
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_C_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_foo(base SwigcptrC) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrC) Foo() (_swig_ret int) {
|
||||
return _swig_wrap_C_foo(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
Foo() (_swig_ret int)
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_new_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_D() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewD() (_swig_ret D) {
|
||||
return _swig_wrap_new_D()
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_D_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_foo(base SwigcptrD) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrD) Foo() (_swig_ret int) {
|
||||
return _swig_wrap_D_foo(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetB() B {
|
||||
return SwigcptrB(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_D_SwigGetC unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_SwigGetC(base SwigcptrD) (_ SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_SwigGetC, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrD) SwigGetC() (_swig_ret C) {
|
||||
return _swig_wrap_D_SwigGetC(arg1)
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
Foo() (_swig_ret int)
|
||||
SwigIsB()
|
||||
SwigGetB() B
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
SwigGetC() (_swig_ret C)
|
||||
}
|
||||
|
||||
type SwigcptrE uintptr
|
||||
|
||||
func (p SwigcptrE) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsE() {
|
||||
}
|
||||
|
||||
var _wrap_new_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E() (base SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE() (_swig_ret E) {
|
||||
return _swig_wrap_new_E()
|
||||
}
|
||||
|
||||
var _wrap_delete_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_E(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteE(arg1 E) {
|
||||
_swig_wrap_delete_E(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_E_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_E_foo(base SwigcptrE) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_E_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrE) Foo() (_swig_ret int) {
|
||||
return _swig_wrap_E_foo(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsC() {
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigGetC() C {
|
||||
return SwigcptrC(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_E_SwigGetB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_E_SwigGetB(base SwigcptrE) (_ SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_E_SwigGetB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrE) SwigGetB() (_swig_ret B) {
|
||||
return _swig_wrap_E_SwigGetB(arg1)
|
||||
}
|
||||
|
||||
type E interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsE()
|
||||
Foo() (_swig_ret int)
|
||||
SwigIsC()
|
||||
SwigGetC() C
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
SwigGetB() (_swig_ret B)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,438 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../access_change.i
|
||||
|
||||
package access_change
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrBaseInt uintptr
|
||||
|
||||
func (p SwigcptrBaseInt) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBaseInt) SwigIsBaseInt() {
|
||||
}
|
||||
|
||||
var _wrap_delete_BaseInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_BaseInt(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_BaseInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBaseInt(arg1 BaseInt) {
|
||||
_swig_wrap_delete_BaseInt(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_BaseInt_PublicProtectedPublic1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BaseInt_PublicProtectedPublic1(base SwigcptrBaseInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BaseInt_PublicProtectedPublic1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBaseInt) PublicProtectedPublic1() (_swig_ret *int) {
|
||||
return _swig_wrap_BaseInt_PublicProtectedPublic1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BaseInt_PublicProtectedPublic2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BaseInt_PublicProtectedPublic2(base SwigcptrBaseInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BaseInt_PublicProtectedPublic2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBaseInt) PublicProtectedPublic2() (_swig_ret *int) {
|
||||
return _swig_wrap_BaseInt_PublicProtectedPublic2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BaseInt_PublicProtectedPublic3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BaseInt_PublicProtectedPublic3(base SwigcptrBaseInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BaseInt_PublicProtectedPublic3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBaseInt) PublicProtectedPublic3() (_swig_ret *int) {
|
||||
return _swig_wrap_BaseInt_PublicProtectedPublic3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BaseInt_PublicProtectedPublic4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BaseInt_PublicProtectedPublic4(base SwigcptrBaseInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BaseInt_PublicProtectedPublic4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBaseInt) PublicProtectedPublic4() (_swig_ret *int) {
|
||||
return _swig_wrap_BaseInt_PublicProtectedPublic4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_BaseInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_BaseInt() (base SwigcptrBaseInt) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_BaseInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBaseInt() (_swig_ret BaseInt) {
|
||||
return _swig_wrap_new_BaseInt()
|
||||
}
|
||||
|
||||
type BaseInt interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBaseInt()
|
||||
PublicProtectedPublic1() (_swig_ret *int)
|
||||
PublicProtectedPublic2() (_swig_ret *int)
|
||||
PublicProtectedPublic3() (_swig_ret *int)
|
||||
PublicProtectedPublic4() (_swig_ret *int)
|
||||
}
|
||||
|
||||
type SwigcptrDerivedInt uintptr
|
||||
|
||||
func (p SwigcptrDerivedInt) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDerivedInt) SwigIsDerivedInt() {
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_WasProtected1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_WasProtected1(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_WasProtected1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerivedInt) WasProtected1() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_WasProtected1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_WasProtected2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_WasProtected2(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_WasProtected2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerivedInt) WasProtected2() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_WasProtected2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_WasProtected3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_WasProtected3(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_WasProtected3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerivedInt) WasProtected3() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_WasProtected3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_WasProtected4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_WasProtected4(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_WasProtected4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerivedInt) WasProtected4() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_WasProtected4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_DerivedInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_DerivedInt() (base SwigcptrDerivedInt) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_DerivedInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDerivedInt() (_swig_ret DerivedInt) {
|
||||
return _swig_wrap_new_DerivedInt()
|
||||
}
|
||||
|
||||
var _wrap_delete_DerivedInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_DerivedInt(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_DerivedInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDerivedInt(arg1 DerivedInt) {
|
||||
_swig_wrap_delete_DerivedInt(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_PublicProtectedPublic1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_PublicProtectedPublic1(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_PublicProtectedPublic1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerivedInt) PublicProtectedPublic1() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_PublicProtectedPublic1(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_PublicProtectedPublic2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_PublicProtectedPublic2(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_PublicProtectedPublic2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerivedInt) PublicProtectedPublic2() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_PublicProtectedPublic2(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_PublicProtectedPublic3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_PublicProtectedPublic3(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_PublicProtectedPublic3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerivedInt) PublicProtectedPublic3() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_PublicProtectedPublic3(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_DerivedInt_PublicProtectedPublic4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerivedInt_PublicProtectedPublic4(base SwigcptrDerivedInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerivedInt_PublicProtectedPublic4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerivedInt) PublicProtectedPublic4() (_swig_ret *int) {
|
||||
return _swig_wrap_DerivedInt_PublicProtectedPublic4(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrDerivedInt) SwigIsBaseInt() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDerivedInt) SwigGetBaseInt() BaseInt {
|
||||
return SwigcptrBaseInt(p.Swigcptr())
|
||||
}
|
||||
|
||||
type DerivedInt interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDerivedInt()
|
||||
WasProtected1() (_swig_ret *int)
|
||||
WasProtected2() (_swig_ret *int)
|
||||
WasProtected3() (_swig_ret *int)
|
||||
WasProtected4() (_swig_ret *int)
|
||||
PublicProtectedPublic1() (_swig_ret *int)
|
||||
PublicProtectedPublic2() (_swig_ret *int)
|
||||
PublicProtectedPublic3() (_swig_ret *int)
|
||||
PublicProtectedPublic4() (_swig_ret *int)
|
||||
SwigIsBaseInt()
|
||||
SwigGetBaseInt() BaseInt
|
||||
}
|
||||
|
||||
type SwigcptrBottomInt uintptr
|
||||
|
||||
func (p SwigcptrBottomInt) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBottomInt) SwigIsBottomInt() {
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_WasProtected1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_WasProtected1(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_WasProtected1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) WasProtected1() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_WasProtected1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_WasProtected2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_WasProtected2(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_WasProtected2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) WasProtected2() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_WasProtected2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_WasProtected3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_WasProtected3(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_WasProtected3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) WasProtected3() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_WasProtected3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_WasProtected4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_WasProtected4(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_WasProtected4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) WasProtected4() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_WasProtected4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_PublicProtectedPublic1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_PublicProtectedPublic1(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_PublicProtectedPublic1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) PublicProtectedPublic1() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_PublicProtectedPublic1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_PublicProtectedPublic2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_PublicProtectedPublic2(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_PublicProtectedPublic2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) PublicProtectedPublic2() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_PublicProtectedPublic2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_PublicProtectedPublic3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_PublicProtectedPublic3(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_PublicProtectedPublic3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) PublicProtectedPublic3() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_PublicProtectedPublic3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BottomInt_PublicProtectedPublic4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BottomInt_PublicProtectedPublic4(base SwigcptrBottomInt) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BottomInt_PublicProtectedPublic4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBottomInt) PublicProtectedPublic4() (_swig_ret *int) {
|
||||
return _swig_wrap_BottomInt_PublicProtectedPublic4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_BottomInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_BottomInt() (base SwigcptrBottomInt) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_BottomInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBottomInt() (_swig_ret BottomInt) {
|
||||
return _swig_wrap_new_BottomInt()
|
||||
}
|
||||
|
||||
var _wrap_delete_BottomInt unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_BottomInt(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_BottomInt, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBottomInt(arg1 BottomInt) {
|
||||
_swig_wrap_delete_BottomInt(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrBottomInt) SwigIsDerivedInt() {
|
||||
}
|
||||
|
||||
func (p SwigcptrBottomInt) SwigGetDerivedInt() DerivedInt {
|
||||
return SwigcptrDerivedInt(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrBottomInt) SwigIsBaseInt() {
|
||||
}
|
||||
|
||||
func (p SwigcptrBottomInt) SwigGetBaseInt() BaseInt {
|
||||
return SwigcptrBaseInt(p.Swigcptr())
|
||||
}
|
||||
|
||||
type BottomInt interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBottomInt()
|
||||
WasProtected1() (_swig_ret *int)
|
||||
WasProtected2() (_swig_ret *int)
|
||||
WasProtected3() (_swig_ret *int)
|
||||
WasProtected4() (_swig_ret *int)
|
||||
PublicProtectedPublic1() (_swig_ret *int)
|
||||
PublicProtectedPublic2() (_swig_ret *int)
|
||||
PublicProtectedPublic3() (_swig_ret *int)
|
||||
PublicProtectedPublic4() (_swig_ret *int)
|
||||
SwigIsDerivedInt()
|
||||
SwigGetDerivedInt() DerivedInt
|
||||
SwigIsBaseInt()
|
||||
SwigGetBaseInt() BaseInt
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../add_link.i
|
||||
|
||||
package add_link
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_Foo_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_blah(base SwigcptrFoo) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Blah() (_swig_ret Foo) {
|
||||
return _swig_wrap_Foo_blah(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Blah() (_swig_ret Foo)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../aggregate.i
|
||||
|
||||
package aggregate
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const UP int = 1
|
||||
const DOWN int = 2
|
||||
const LEFT int = 3
|
||||
const RIGHT int = 4
|
||||
var _wrap_move unsafe.Pointer
|
||||
|
||||
func Move(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_move, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -1,241 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../allowexcept.i
|
||||
|
||||
package allowexcept
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrUVW uintptr
|
||||
|
||||
func (p SwigcptrUVW) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrUVW) SwigIsUVW() {
|
||||
}
|
||||
|
||||
type UVW interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsUVW()
|
||||
}
|
||||
|
||||
var _wrap_uvw_global_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_uvw_global_variable_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_uvw_global_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetUvw_global_variable(arg1 UVW) {
|
||||
_swig_wrap_uvw_global_variable_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_uvw_global_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_uvw_global_variable_get() (base SwigcptrUVW) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_uvw_global_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetUvw_global_variable() (_swig_ret UVW) {
|
||||
return _swig_wrap_uvw_global_variable_get()
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_member_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_member_variable_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_member_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetMember_variable(arg2 UVW) {
|
||||
_swig_wrap_Bar_member_variable_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_member_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_member_variable_get(base SwigcptrBar) (_ SwigcptrUVW) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_member_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetMember_variable() (_swig_ret UVW) {
|
||||
return _swig_wrap_Bar_member_variable_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_static_member_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_static_member_variable_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_static_member_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBarStatic_member_variable(arg1 UVW) {
|
||||
_swig_wrap_Bar_static_member_variable_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_static_member_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_static_member_variable_get() (base SwigcptrUVW) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_static_member_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetBarStatic_member_variable() (_swig_ret UVW) {
|
||||
return _swig_wrap_Bar_static_member_variable_get()
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
SetMember_variable(arg2 UVW)
|
||||
GetMember_variable() (_swig_ret UVW)
|
||||
}
|
||||
|
||||
type SwigcptrXYZ uintptr
|
||||
|
||||
func (p SwigcptrXYZ) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrXYZ) SwigIsXYZ() {
|
||||
}
|
||||
|
||||
type XYZ interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsXYZ()
|
||||
}
|
||||
|
||||
var _wrap_global_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_variable_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobal_variable(arg1 XYZ) {
|
||||
_swig_wrap_global_variable_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_global_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_variable_get() (base SwigcptrXYZ) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetGlobal_variable() (_swig_ret XYZ) {
|
||||
return _swig_wrap_global_variable_get()
|
||||
}
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_member_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_member_variable_set(base SwigcptrFoo, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_member_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetMember_variable(arg2 XYZ) {
|
||||
_swig_wrap_Foo_member_variable_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_member_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_member_variable_get(base SwigcptrFoo) (_ SwigcptrXYZ) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_member_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetMember_variable() (_swig_ret XYZ) {
|
||||
return _swig_wrap_Foo_member_variable_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_static_member_variable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_static_member_variable_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_static_member_variable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetFooStatic_member_variable(arg1 XYZ) {
|
||||
_swig_wrap_Foo_static_member_variable_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_static_member_variable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_static_member_variable_get() (base SwigcptrXYZ) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_static_member_variable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetFooStatic_member_variable() (_swig_ret XYZ) {
|
||||
return _swig_wrap_Foo_static_member_variable_get()
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetMember_variable(arg2 XYZ)
|
||||
GetMember_variable() (_swig_ret XYZ)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,681 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../allprotected.i
|
||||
|
||||
package allprotected
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrKlass uintptr
|
||||
|
||||
func (p SwigcptrKlass) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrKlass) SwigIsKlass() {
|
||||
}
|
||||
|
||||
var _wrap_new_Klass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Klass(base string) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Klass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewKlass(arg1 string) (_swig_ret Klass) {
|
||||
return _swig_wrap_new_Klass(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Klass_getName unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Klass_getName(base SwigcptrKlass) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Klass_getName, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrKlass) GetName() (_swig_ret string) {
|
||||
return _swig_wrap_Klass_getName(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Klass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Klass(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Klass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteKlass(arg1 Klass) {
|
||||
_swig_wrap_delete_Klass(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Klass interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsKlass()
|
||||
GetName() (_swig_ret string)
|
||||
}
|
||||
|
||||
type _swig_DirectorPublicBase struct {
|
||||
SwigcptrPublicBase
|
||||
v interface{}
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorPublicBase) Swigcptr() uintptr {
|
||||
return p.SwigcptrPublicBase.Swigcptr()
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorPublicBase) SwigIsPublicBase() {
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorPublicBase) DirectorInterface() interface{} {
|
||||
return p.v
|
||||
}
|
||||
|
||||
var _wrap__swig_NewDirectorPublicBasePublicBase unsafe.Pointer
|
||||
|
||||
func _swig_NewDirectorPublicBasePublicBase(_swig_director *_swig_DirectorPublicBase, _ string) (_swig_ret SwigcptrPublicBase) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_director))
|
||||
_cgo_runtime_cgocall(_wrap__swig_NewDirectorPublicBasePublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorPublicBase(v interface{}, arg1 string) PublicBase {
|
||||
p := &_swig_DirectorPublicBase{0, v}
|
||||
p.SwigcptrPublicBase = _swig_NewDirectorPublicBasePublicBase(p, arg1)
|
||||
return p
|
||||
}
|
||||
|
||||
var _wrap_DeleteDirectorPublicBase unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DeleteDirectorPublicBase(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DeleteDirectorPublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDirectorPublicBase(arg1 PublicBase) {
|
||||
_swig_wrap_DeleteDirectorPublicBase(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func Swiggo_DeleteDirector_PublicBase(p *_swig_DirectorPublicBase) {
|
||||
p.SwigcptrPublicBase = 0
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfacePublicBaseVirtualMethod interface {
|
||||
VirtualMethod() string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorPublicBase_upcall_VirtualMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorPublicBase_upcall_VirtualMethod(_swig_ptr SwigcptrPublicBase) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorPublicBase_upcall_VirtualMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorPublicBase) VirtualMethod() string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfacePublicBaseVirtualMethod); swig_ok {
|
||||
return swig_g.VirtualMethod()
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorPublicBase_upcall_VirtualMethod(swig_p.SwigcptrPublicBase)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorPublicBaseVirtualMethod(p PublicBase) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorPublicBase_upcall_VirtualMethod(p.(*_swig_DirectorPublicBase).SwigcptrPublicBase)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorPublicBase_callback_virtualMethod(p *_swig_DirectorPublicBase) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.VirtualMethod()
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type SwigcptrPublicBase uintptr
|
||||
|
||||
func (p SwigcptrPublicBase) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrPublicBase) SwigIsPublicBase() {
|
||||
}
|
||||
|
||||
func (p SwigcptrPublicBase) DirectorInterface() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
type PublicBaseAnEnum int
|
||||
var _wrap_EnumVal1_PublicBase unsafe.Pointer
|
||||
|
||||
func _swig_getPublicBase_EnumVal1_PublicBase() (_swig_ret PublicBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_EnumVal1_PublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var PublicBaseEnumVal1 PublicBaseAnEnum = _swig_getPublicBase_EnumVal1_PublicBase()
|
||||
var _wrap_EnumVal2_PublicBase unsafe.Pointer
|
||||
|
||||
func _swig_getPublicBase_EnumVal2_PublicBase() (_swig_ret PublicBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_EnumVal2_PublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var PublicBaseEnumVal2 PublicBaseAnEnum = _swig_getPublicBase_EnumVal2_PublicBase()
|
||||
var _wrap_new_PublicBase unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_PublicBase(base string) (_ SwigcptrPublicBase) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_PublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewPublicBase(arg1 string) (_swig_ret PublicBase) {
|
||||
return _swig_wrap_new_PublicBase(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_PublicBase unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_PublicBase(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_PublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeletePublicBase(arg1 PublicBase) {
|
||||
_swig_wrap_delete_PublicBase(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_virtualMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_virtualMethod(base SwigcptrPublicBase) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_virtualMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) VirtualMethod() (_swig_ret string) {
|
||||
return _swig_wrap_PublicBase_virtualMethod(arg1)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_instanceMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_instanceMethod(base SwigcptrPublicBase, _ uintptr) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_instanceMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) InstanceMethod(arg2 Klass) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_instanceMethod(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_instanceOverloaded__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_instanceOverloaded__SWIG_0(base SwigcptrPublicBase, _ uintptr) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_instanceOverloaded__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) InstanceOverloaded__SWIG_0(arg2 Klass) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_instanceOverloaded__SWIG_0(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_instanceOverloaded__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_instanceOverloaded__SWIG_1(base SwigcptrPublicBase, _ uintptr, _ string) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_instanceOverloaded__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) InstanceOverloaded__SWIG_1(arg2 Klass, arg3 string) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_instanceOverloaded__SWIG_1(arg1, arg2.Swigcptr(), arg3)
|
||||
}
|
||||
|
||||
func (p SwigcptrPublicBase) InstanceOverloaded(a ...interface{}) Klass {
|
||||
argc := len(a)
|
||||
if argc == 1 {
|
||||
return p.InstanceOverloaded__SWIG_0(a[0].(Klass))
|
||||
}
|
||||
if argc == 2 {
|
||||
return p.InstanceOverloaded__SWIG_1(a[0].(Klass), a[1].(string))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_staticMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_staticMethod(base uintptr) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func PublicBaseStaticMethod(arg1 Klass) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_staticMethod(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_staticOverloaded__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_staticOverloaded__SWIG_0(base uintptr) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticOverloaded__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func PublicBaseStaticOverloaded__SWIG_0(arg1 Klass) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_staticOverloaded__SWIG_0(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_staticOverloaded__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_staticOverloaded__SWIG_1(base uintptr, _ string) (_ SwigcptrKlass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticOverloaded__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func PublicBaseStaticOverloaded__SWIG_1(arg1 Klass, arg2 string) (_swig_ret Klass) {
|
||||
return _swig_wrap_PublicBase_staticOverloaded__SWIG_1(arg1.Swigcptr(), arg2)
|
||||
}
|
||||
|
||||
func PublicBaseStaticOverloaded(a ...interface{}) Klass {
|
||||
argc := len(a)
|
||||
if argc == 1 {
|
||||
return PublicBaseStaticOverloaded__SWIG_0(a[0].(Klass))
|
||||
}
|
||||
if argc == 2 {
|
||||
return PublicBaseStaticOverloaded__SWIG_1(a[0].(Klass), a[1].(string))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_instanceMemberVariable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_instanceMemberVariable_set(base SwigcptrPublicBase, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_instanceMemberVariable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) SetInstanceMemberVariable(arg2 int) {
|
||||
_swig_wrap_PublicBase_instanceMemberVariable_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_instanceMemberVariable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_instanceMemberVariable_get(base SwigcptrPublicBase) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_instanceMemberVariable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) GetInstanceMemberVariable() (_swig_ret int) {
|
||||
return _swig_wrap_PublicBase_instanceMemberVariable_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_staticMemberVariable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_staticMemberVariable_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticMemberVariable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetPublicBaseStaticMemberVariable(arg1 int) {
|
||||
_swig_wrap_PublicBase_staticMemberVariable_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_staticMemberVariable_get unsafe.Pointer
|
||||
|
||||
func GetPublicBaseStaticMemberVariable() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticMemberVariable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_PublicBase_staticConstMemberVariable_PublicBase unsafe.Pointer
|
||||
|
||||
func _swig_getPublicBase_PublicBase_staticConstMemberVariable_PublicBase() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_staticConstMemberVariable_PublicBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var PublicBaseStaticConstMemberVariable int = _swig_getPublicBase_PublicBase_staticConstMemberVariable_PublicBase()
|
||||
var _wrap_PublicBase_anEnum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_anEnum_set(base SwigcptrPublicBase, _ PublicBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_anEnum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) SetAnEnum(arg2 PublicBaseAnEnum) {
|
||||
_swig_wrap_PublicBase_anEnum_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_anEnum_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_anEnum_get(base SwigcptrPublicBase) (_ PublicBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_anEnum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) GetAnEnum() (_swig_ret PublicBaseAnEnum) {
|
||||
return _swig_wrap_PublicBase_anEnum_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_stringMember_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_stringMember_set(base SwigcptrPublicBase, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_stringMember_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) SetStringMember(arg2 string) {
|
||||
_swig_wrap_PublicBase_stringMember_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_PublicBase_stringMember_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_PublicBase_stringMember_get(base SwigcptrPublicBase) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_PublicBase_stringMember_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrPublicBase) GetStringMember() (_swig_ret string) {
|
||||
return _swig_wrap_PublicBase_stringMember_get(arg1)
|
||||
}
|
||||
|
||||
type PublicBase interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsPublicBase()
|
||||
DirectorInterface() interface{}
|
||||
VirtualMethod() (_swig_ret string)
|
||||
InstanceMethod(arg2 Klass) (_swig_ret Klass)
|
||||
InstanceOverloaded(a ...interface{}) Klass
|
||||
SetInstanceMemberVariable(arg2 int)
|
||||
GetInstanceMemberVariable() (_swig_ret int)
|
||||
SetAnEnum(arg2 PublicBaseAnEnum)
|
||||
GetAnEnum() (_swig_ret PublicBaseAnEnum)
|
||||
SetStringMember(arg2 string)
|
||||
GetStringMember() (_swig_ret string)
|
||||
}
|
||||
|
||||
type _swig_DirectorProtectedBase struct {
|
||||
SwigcptrProtectedBase
|
||||
v interface{}
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorProtectedBase) Swigcptr() uintptr {
|
||||
return p.SwigcptrProtectedBase.Swigcptr()
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorProtectedBase) SwigIsProtectedBase() {
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorProtectedBase) DirectorInterface() interface{} {
|
||||
return p.v
|
||||
}
|
||||
|
||||
var _wrap__swig_NewDirectorProtectedBaseProtectedBase unsafe.Pointer
|
||||
|
||||
func _swig_NewDirectorProtectedBaseProtectedBase(_swig_director *_swig_DirectorProtectedBase, _ string) (_swig_ret SwigcptrProtectedBase) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_director))
|
||||
_cgo_runtime_cgocall(_wrap__swig_NewDirectorProtectedBaseProtectedBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorProtectedBase(v interface{}, arg1 string) ProtectedBase {
|
||||
p := &_swig_DirectorProtectedBase{0, v}
|
||||
p.SwigcptrProtectedBase = _swig_NewDirectorProtectedBaseProtectedBase(p, arg1)
|
||||
return p
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceProtectedBaseVirtualMethod interface {
|
||||
VirtualMethod() string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorProtectedBase_upcall_VirtualMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorProtectedBase_upcall_VirtualMethod(_swig_ptr SwigcptrProtectedBase) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorProtectedBase_upcall_VirtualMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorProtectedBase) VirtualMethod() string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceProtectedBaseVirtualMethod); swig_ok {
|
||||
return swig_g.VirtualMethod()
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorProtectedBase_upcall_VirtualMethod(swig_p.SwigcptrProtectedBase)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorProtectedBaseVirtualMethod(p ProtectedBase) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorProtectedBase_upcall_VirtualMethod(p.(*_swig_DirectorProtectedBase).SwigcptrProtectedBase)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorProtectedBase_callback_virtualMethod(p *_swig_DirectorProtectedBase) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.VirtualMethod()
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type SwigcptrProtectedBase uintptr
|
||||
|
||||
func (p SwigcptrProtectedBase) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrProtectedBase) SwigIsProtectedBase() {
|
||||
}
|
||||
|
||||
func (p SwigcptrProtectedBase) DirectorInterface() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
type ProtectedBaseAnEnum int
|
||||
var _wrap_EnumVal1_ProtectedBase unsafe.Pointer
|
||||
|
||||
func _swig_getProtectedBase_EnumVal1_ProtectedBase() (_swig_ret ProtectedBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_EnumVal1_ProtectedBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var ProtectedBaseEnumVal1 ProtectedBaseAnEnum = _swig_getProtectedBase_EnumVal1_ProtectedBase()
|
||||
var _wrap_EnumVal2_ProtectedBase unsafe.Pointer
|
||||
|
||||
func _swig_getProtectedBase_EnumVal2_ProtectedBase() (_swig_ret ProtectedBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_EnumVal2_ProtectedBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var ProtectedBaseEnumVal2 ProtectedBaseAnEnum = _swig_getProtectedBase_EnumVal2_ProtectedBase()
|
||||
var _wrap_ProtectedBase_getName unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_getName(base SwigcptrProtectedBase) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_getName, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) GetName() (_swig_ret string) {
|
||||
return _swig_wrap_ProtectedBase_getName(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_ProtectedBase unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_ProtectedBase(base string) (_ SwigcptrProtectedBase) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_ProtectedBase, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewProtectedBase(arg1 string) (_swig_ret ProtectedBase) {
|
||||
return _swig_wrap_new_ProtectedBase(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_instanceMemberVariable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_instanceMemberVariable_set(base SwigcptrProtectedBase, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_instanceMemberVariable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) SetInstanceMemberVariable(arg2 int) {
|
||||
_swig_wrap_ProtectedBase_instanceMemberVariable_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_instanceMemberVariable_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_instanceMemberVariable_get(base SwigcptrProtectedBase) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_instanceMemberVariable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) GetInstanceMemberVariable() (_swig_ret int) {
|
||||
return _swig_wrap_ProtectedBase_instanceMemberVariable_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_staticMemberVariable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_staticMemberVariable_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_staticMemberVariable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetProtectedBaseStaticMemberVariable(arg1 int) {
|
||||
_swig_wrap_ProtectedBase_staticMemberVariable_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_staticMemberVariable_get unsafe.Pointer
|
||||
|
||||
func GetProtectedBaseStaticMemberVariable() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_staticMemberVariable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ProtectedBase_staticConstMemberVariable_ProtectedBase unsafe.Pointer
|
||||
|
||||
func _swig_getProtectedBase_ProtectedBase_staticConstMemberVariable_ProtectedBase() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_staticConstMemberVariable_ProtectedBase, _swig_p)
|
||||
return
|
||||
}
|
||||
var ProtectedBaseStaticConstMemberVariable int = _swig_getProtectedBase_ProtectedBase_staticConstMemberVariable_ProtectedBase()
|
||||
var _wrap_ProtectedBase_anEnum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_anEnum_set(base SwigcptrProtectedBase, _ ProtectedBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_anEnum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) SetAnEnum(arg2 ProtectedBaseAnEnum) {
|
||||
_swig_wrap_ProtectedBase_anEnum_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_anEnum_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_anEnum_get(base SwigcptrProtectedBase) (_ ProtectedBaseAnEnum) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_anEnum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) GetAnEnum() (_swig_ret ProtectedBaseAnEnum) {
|
||||
return _swig_wrap_ProtectedBase_anEnum_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_stringMember_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_stringMember_set(base SwigcptrProtectedBase, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_stringMember_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) SetStringMember(arg2 string) {
|
||||
_swig_wrap_ProtectedBase_stringMember_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ProtectedBase_stringMember_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ProtectedBase_stringMember_get(base SwigcptrProtectedBase) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ProtectedBase_stringMember_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrProtectedBase) GetStringMember() (_swig_ret string) {
|
||||
return _swig_wrap_ProtectedBase_stringMember_get(arg1)
|
||||
}
|
||||
|
||||
type ProtectedBaseProtectedEnum int
|
||||
type ProtectedBase interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsProtectedBase()
|
||||
DirectorInterface() interface{}
|
||||
GetName() (_swig_ret string)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrSwigDirector_ProtectedBase uintptr
|
||||
type SwigDirector_ProtectedBase interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrSwigDirector_ProtectedBase) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrSwigDirector_PublicBase uintptr
|
||||
type SwigDirector_PublicBase interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrSwigDirector_PublicBase) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../allprotected_not.i
|
||||
|
||||
package allprotected_not
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrAllProtectedNot uintptr
|
||||
|
||||
func (p SwigcptrAllProtectedNot) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAllProtectedNot) SwigIsAllProtectedNot() {
|
||||
}
|
||||
|
||||
var _wrap_delete_AllProtectedNot unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_AllProtectedNot(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_AllProtectedNot, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAllProtectedNot(arg1 AllProtectedNot) {
|
||||
_swig_wrap_delete_AllProtectedNot(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_AllProtectedNot_PublicMethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_AllProtectedNot_PublicMethod(base SwigcptrAllProtectedNot) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_AllProtectedNot_PublicMethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAllProtectedNot) PublicMethod() {
|
||||
_swig_wrap_AllProtectedNot_PublicMethod(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_AllProtectedNot unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_AllProtectedNot() (base SwigcptrAllProtectedNot) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_AllProtectedNot, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewAllProtectedNot() (_swig_ret AllProtectedNot) {
|
||||
return _swig_wrap_new_AllProtectedNot()
|
||||
}
|
||||
|
||||
type AllProtectedNot interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAllProtectedNot()
|
||||
PublicMethod()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../allprotected_not.i
|
||||
|
||||
#ifndef SWIG_allprotected_not_WRAP_H_
|
||||
#define SWIG_allprotected_not_WRAP_H_
|
||||
|
||||
#endif
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../allprotected.i
|
||||
|
||||
#ifndef SWIG_allprotected_WRAP_H_
|
||||
#define SWIG_allprotected_WRAP_H_
|
||||
|
||||
class SwigDirector_PublicBase : public PublicBase
|
||||
{
|
||||
public:
|
||||
SwigDirector_PublicBase(void *swig_p, char const *s);
|
||||
virtual ~SwigDirector_PublicBase();
|
||||
std::string _swig_upcall_virtualMethod() const {
|
||||
return PublicBase::virtualMethod();
|
||||
}
|
||||
virtual std::string virtualMethod() const;
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_ProtectedBase : public ProtectedBase
|
||||
{
|
||||
public:
|
||||
SwigDirector_ProtectedBase(void *swig_p, char const *s);
|
||||
std::string _swig_upcall_virtualMethod() const {
|
||||
return ProtectedBase::virtualMethod();
|
||||
}
|
||||
virtual std::string virtualMethod() const;
|
||||
using ProtectedBase::instanceMethod;
|
||||
using ProtectedBase::instanceOverloaded;
|
||||
using ProtectedBase::staticMethod;
|
||||
using ProtectedBase::staticOverloaded;
|
||||
using ProtectedBase::instanceMemberVariable;
|
||||
using ProtectedBase::staticMemberVariable;
|
||||
using ProtectedBase::staticConstMemberVariable;
|
||||
using ProtectedBase::anEnum;
|
||||
using ProtectedBase::stringMember;
|
||||
using ProtectedBase::IntegerType;
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,205 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../anonymous_bitfield.i
|
||||
|
||||
package anonymous_bitfield
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_x_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_x_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_x_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetX(arg2 int) {
|
||||
_swig_wrap_Foo_x_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_x_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_x_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_x_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetX() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_x_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_y_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_y_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_y_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetY(arg2 int) {
|
||||
_swig_wrap_Foo_y_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_y_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_y_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_y_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetY() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_y_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_f_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_f_set(base SwigcptrFoo, _ uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_f_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetF(arg2 uint) {
|
||||
_swig_wrap_Foo_f_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_f_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_f_get(base SwigcptrFoo) (_ uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_f_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetF() (_swig_ret uint) {
|
||||
return _swig_wrap_Foo_f_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_z_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_z_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_z_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetZ(arg2 int) {
|
||||
_swig_wrap_Foo_z_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_z_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_z_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_z_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetZ() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_z_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_seq_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_seq_set(base SwigcptrFoo, _ uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_seq_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetSeq(arg2 uint) {
|
||||
_swig_wrap_Foo_seq_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_seq_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_seq_get(base SwigcptrFoo) (_ uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_seq_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetSeq() (_swig_ret uint) {
|
||||
return _swig_wrap_Foo_seq_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetX(arg2 int)
|
||||
GetX() (_swig_ret int)
|
||||
SetY(arg2 int)
|
||||
GetY() (_swig_ret int)
|
||||
SetF(arg2 uint)
|
||||
GetF() (_swig_ret uint)
|
||||
SetZ(arg2 int)
|
||||
GetZ() (_swig_ret int)
|
||||
SetSeq(arg2 uint)
|
||||
GetSeq() (_swig_ret uint)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,358 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../apply_signed_char.i
|
||||
|
||||
package apply_signed_char
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_CharValFunction unsafe.Pointer
|
||||
|
||||
func CharValFunction(arg1 int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CCharValFunction unsafe.Pointer
|
||||
|
||||
func CCharValFunction(arg1 int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CCharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CCharRefFunction unsafe.Pointer
|
||||
|
||||
func CCharRefFunction(arg1 int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CCharRefFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_globalchar_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_globalchar_set(base int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_globalchar_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobalchar(arg1 int8) {
|
||||
_swig_wrap_globalchar_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_globalchar_get unsafe.Pointer
|
||||
|
||||
func GetGlobalchar() (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_globalchar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_globalconstchar_get unsafe.Pointer
|
||||
|
||||
func GetGlobalconstchar() (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_globalconstchar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
type _swig_DirectorDirectorTest struct {
|
||||
SwigcptrDirectorTest
|
||||
v interface{}
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) Swigcptr() uintptr {
|
||||
return p.SwigcptrDirectorTest.Swigcptr()
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) SwigIsDirectorTest() {
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) DirectorInterface() interface{} {
|
||||
return p.v
|
||||
}
|
||||
|
||||
var _wrap__swig_NewDirectorDirectorTestDirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_NewDirectorDirectorTestDirectorTest(_swig_director *_swig_DirectorDirectorTest) (_swig_ret SwigcptrDirectorTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_director))
|
||||
_cgo_runtime_cgocall(_wrap__swig_NewDirectorDirectorTestDirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorDirectorTest(v interface{}) DirectorTest {
|
||||
p := &_swig_DirectorDirectorTest{0, v}
|
||||
p.SwigcptrDirectorTest = _swig_NewDirectorDirectorTestDirectorTest(p)
|
||||
return p
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCharValFunction interface {
|
||||
CharValFunction(int8) int8
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CharValFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CharValFunction(_swig_ptr SwigcptrDirectorTest, _ int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CharValFunction(number int8) int8 {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCharValFunction); swig_ok {
|
||||
return swig_g.CharValFunction(number)
|
||||
}
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CharValFunction(swig_p.SwigcptrDirectorTest, number)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCharValFunction(p DirectorTest, arg2 int8) int8 {
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CharValFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CharValFunction(p *_swig_DirectorDirectorTest, arg2 int8) (swig_result int8) {
|
||||
var swig_r int8
|
||||
swig_r = p.CharValFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCCharValFunction interface {
|
||||
CCharValFunction(int8) int8
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CCharValFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CCharValFunction(_swig_ptr SwigcptrDirectorTest, _ int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CCharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CCharValFunction(number int8) int8 {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCCharValFunction); swig_ok {
|
||||
return swig_g.CCharValFunction(number)
|
||||
}
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharValFunction(swig_p.SwigcptrDirectorTest, number)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCCharValFunction(p DirectorTest, arg2 int8) int8 {
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharValFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CCharValFunction(p *_swig_DirectorDirectorTest, arg2 int8) (swig_result int8) {
|
||||
var swig_r int8
|
||||
swig_r = p.CCharValFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCCharRefFunction interface {
|
||||
CCharRefFunction(int8) int8
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CCharRefFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CCharRefFunction(_swig_ptr SwigcptrDirectorTest, _ int8) (_swig_ret int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CCharRefFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CCharRefFunction(number int8) int8 {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCCharRefFunction); swig_ok {
|
||||
return swig_g.CCharRefFunction(number)
|
||||
}
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharRefFunction(swig_p.SwigcptrDirectorTest, number)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCCharRefFunction(p DirectorTest, arg2 int8) int8 {
|
||||
var swig_r int8
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharRefFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CCharRefFunction(p *_swig_DirectorDirectorTest, arg2 int8) (swig_result int8) {
|
||||
var swig_r int8
|
||||
swig_r = p.CCharRefFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
var _wrap_DeleteDirectorDirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DeleteDirectorDirectorTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DeleteDirectorDirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDirectorDirectorTest(arg1 DirectorTest) {
|
||||
_swig_wrap_DeleteDirectorDirectorTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func Swiggo_DeleteDirector_DirectorTest(p *_swig_DirectorDirectorTest) {
|
||||
p.SwigcptrDirectorTest = 0
|
||||
}
|
||||
|
||||
type SwigcptrDirectorTest uintptr
|
||||
|
||||
func (p SwigcptrDirectorTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDirectorTest) SwigIsDirectorTest() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDirectorTest) DirectorInterface() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
var _wrap_new_DirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_DirectorTest() (base SwigcptrDirectorTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_DirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorTest() (_swig_ret DirectorTest) {
|
||||
return _swig_wrap_new_DirectorTest()
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CharValFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CharValFunction(base SwigcptrDirectorTest, _ int8) (_ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CharValFunction(arg2 int8) (_swig_ret int8) {
|
||||
return _swig_wrap_DirectorTest_CharValFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CCharValFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CCharValFunction(base SwigcptrDirectorTest, _ int8) (_ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CCharValFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CCharValFunction(arg2 int8) (_swig_ret int8) {
|
||||
return _swig_wrap_DirectorTest_CCharValFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CCharRefFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CCharRefFunction(base SwigcptrDirectorTest, _ int8) (_ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CCharRefFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CCharRefFunction(arg2 int8) (_swig_ret int8) {
|
||||
return _swig_wrap_DirectorTest_CCharRefFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_memberchar_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_memberchar_set(base SwigcptrDirectorTest, _ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_memberchar_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) SetMemberchar(arg2 int8) {
|
||||
_swig_wrap_DirectorTest_memberchar_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_memberchar_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_memberchar_get(base SwigcptrDirectorTest) (_ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_memberchar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) GetMemberchar() (_swig_ret int8) {
|
||||
return _swig_wrap_DirectorTest_memberchar_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_memberconstchar_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_memberconstchar_get(base SwigcptrDirectorTest) (_ int8) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_memberconstchar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) GetMemberconstchar() (_swig_ret int8) {
|
||||
return _swig_wrap_DirectorTest_memberconstchar_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_DirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_DirectorTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_DirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDirectorTest(arg1 DirectorTest) {
|
||||
_swig_wrap_delete_DirectorTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type DirectorTest interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDirectorTest()
|
||||
DirectorInterface() interface{}
|
||||
CharValFunction(arg2 int8) (_swig_ret int8)
|
||||
CCharValFunction(arg2 int8) (_swig_ret int8)
|
||||
CCharRefFunction(arg2 int8) (_swig_ret int8)
|
||||
SetMemberchar(arg2 int8)
|
||||
GetMemberchar() (_swig_ret int8)
|
||||
GetMemberconstchar() (_swig_ret int8)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrSwigDirector_DirectorTest uintptr
|
||||
type SwigDirector_DirectorTest interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrSwigDirector_DirectorTest) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../apply_signed_char.i
|
||||
|
||||
#ifndef SWIG_apply_signed_char_WRAP_H_
|
||||
#define SWIG_apply_signed_char_WRAP_H_
|
||||
|
||||
class SwigDirector_DirectorTest : public DirectorTest
|
||||
{
|
||||
public:
|
||||
SwigDirector_DirectorTest(void *swig_p);
|
||||
char _swig_upcall_CharValFunction(char number) {
|
||||
return DirectorTest::CharValFunction(number);
|
||||
}
|
||||
virtual char CharValFunction(char number);
|
||||
char const _swig_upcall_CCharValFunction(char const number) {
|
||||
return DirectorTest::CCharValFunction(number);
|
||||
}
|
||||
virtual char const CCharValFunction(char const number);
|
||||
char const &_swig_upcall_CCharRefFunction(char const &number) {
|
||||
return DirectorTest::CCharRefFunction(number);
|
||||
}
|
||||
virtual char const &CCharRefFunction(char const &number);
|
||||
virtual ~SwigDirector_DirectorTest();
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,587 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../apply_strings.i
|
||||
|
||||
package apply_strings
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_UCharFunction unsafe.Pointer
|
||||
|
||||
func UCharFunction(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_UCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SCharFunction unsafe.Pointer
|
||||
|
||||
func SCharFunction(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CUCharFunction unsafe.Pointer
|
||||
|
||||
func CUCharFunction(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CUCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CSCharFunction unsafe.Pointer
|
||||
|
||||
func CSCharFunction(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CSCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CharFunction unsafe.Pointer
|
||||
|
||||
func CharFunction(arg1 *byte) (_swig_ret *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CCharFunction unsafe.Pointer
|
||||
|
||||
func CCharFunction(arg1 *byte) (_swig_ret *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrTNumber uintptr
|
||||
|
||||
func (p SwigcptrTNumber) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTNumber) SwigIsTNumber() {
|
||||
}
|
||||
|
||||
var _wrap_TNumber_DigitsMemberA_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TNumber_DigitsMemberA_set(base SwigcptrTNumber, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TNumber_DigitsMemberA_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTNumber) SetDigitsMemberA(arg2 string) {
|
||||
_swig_wrap_TNumber_DigitsMemberA_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_TNumber_DigitsMemberA_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TNumber_DigitsMemberA_get(base SwigcptrTNumber) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TNumber_DigitsMemberA_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTNumber) GetDigitsMemberA() (_swig_ret string) {
|
||||
return _swig_wrap_TNumber_DigitsMemberA_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_TNumber_DigitsMemberB_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TNumber_DigitsMemberB_set(base SwigcptrTNumber, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TNumber_DigitsMemberB_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTNumber) SetDigitsMemberB(arg2 string) {
|
||||
_swig_wrap_TNumber_DigitsMemberB_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_TNumber_DigitsMemberB_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TNumber_DigitsMemberB_get(base SwigcptrTNumber) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TNumber_DigitsMemberB_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTNumber) GetDigitsMemberB() (_swig_ret string) {
|
||||
return _swig_wrap_TNumber_DigitsMemberB_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_TNumber unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_TNumber() (base SwigcptrTNumber) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_TNumber, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTNumber() (_swig_ret TNumber) {
|
||||
return _swig_wrap_new_TNumber()
|
||||
}
|
||||
|
||||
var _wrap_delete_TNumber unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_TNumber(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_TNumber, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTNumber(arg1 TNumber) {
|
||||
_swig_wrap_delete_TNumber(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type TNumber interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTNumber()
|
||||
SetDigitsMemberA(arg2 string)
|
||||
GetDigitsMemberA() (_swig_ret string)
|
||||
SetDigitsMemberB(arg2 string)
|
||||
GetDigitsMemberB() (_swig_ret string)
|
||||
}
|
||||
|
||||
var _wrap_DigitsGlobalA_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DigitsGlobalA_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DigitsGlobalA_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetDigitsGlobalA(arg1 string) {
|
||||
_swig_wrap_DigitsGlobalA_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DigitsGlobalA_get unsafe.Pointer
|
||||
|
||||
func GetDigitsGlobalA() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_DigitsGlobalA_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_DigitsGlobalB_get unsafe.Pointer
|
||||
|
||||
func GetDigitsGlobalB() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_DigitsGlobalB_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_DigitsGlobalC_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DigitsGlobalC_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DigitsGlobalC_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetDigitsGlobalC(arg1 string) {
|
||||
_swig_wrap_DigitsGlobalC_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DigitsGlobalC_get unsafe.Pointer
|
||||
|
||||
func GetDigitsGlobalC() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_DigitsGlobalC_get, _swig_p)
|
||||
return
|
||||
}
|
||||
type _swig_DirectorDirectorTest struct {
|
||||
SwigcptrDirectorTest
|
||||
v interface{}
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) Swigcptr() uintptr {
|
||||
return p.SwigcptrDirectorTest.Swigcptr()
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) SwigIsDirectorTest() {
|
||||
}
|
||||
|
||||
func (p *_swig_DirectorDirectorTest) DirectorInterface() interface{} {
|
||||
return p.v
|
||||
}
|
||||
|
||||
var _wrap__swig_NewDirectorDirectorTestDirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_NewDirectorDirectorTestDirectorTest(_swig_director *_swig_DirectorDirectorTest) (_swig_ret SwigcptrDirectorTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_director))
|
||||
_cgo_runtime_cgocall(_wrap__swig_NewDirectorDirectorTestDirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorDirectorTest(v interface{}) DirectorTest {
|
||||
p := &_swig_DirectorDirectorTest{0, v}
|
||||
p.SwigcptrDirectorTest = _swig_NewDirectorDirectorTestDirectorTest(p)
|
||||
return p
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestUCharFunction interface {
|
||||
UCharFunction(string) string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_UCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_UCharFunction(_swig_ptr SwigcptrDirectorTest, _ string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_UCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) UCharFunction(str string) string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestUCharFunction); swig_ok {
|
||||
return swig_g.UCharFunction(str)
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_UCharFunction(swig_p.SwigcptrDirectorTest, str)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestUCharFunction(p DirectorTest, arg2 string) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_UCharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_UCharFunction(p *_swig_DirectorDirectorTest, arg2 string) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.UCharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestSCharFunction interface {
|
||||
SCharFunction(string) string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_SCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_SCharFunction(_swig_ptr SwigcptrDirectorTest, _ string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_SCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) SCharFunction(str string) string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestSCharFunction); swig_ok {
|
||||
return swig_g.SCharFunction(str)
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_SCharFunction(swig_p.SwigcptrDirectorTest, str)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestSCharFunction(p DirectorTest, arg2 string) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_SCharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_SCharFunction(p *_swig_DirectorDirectorTest, arg2 string) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.SCharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCUCharFunction interface {
|
||||
CUCharFunction(string) string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CUCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CUCharFunction(_swig_ptr SwigcptrDirectorTest, _ string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CUCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CUCharFunction(str string) string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCUCharFunction); swig_ok {
|
||||
return swig_g.CUCharFunction(str)
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CUCharFunction(swig_p.SwigcptrDirectorTest, str)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCUCharFunction(p DirectorTest, arg2 string) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CUCharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CUCharFunction(p *_swig_DirectorDirectorTest, arg2 string) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.CUCharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCSCharFunction interface {
|
||||
CSCharFunction(string) string
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CSCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CSCharFunction(_swig_ptr SwigcptrDirectorTest, _ string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CSCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CSCharFunction(str string) string {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCSCharFunction); swig_ok {
|
||||
return swig_g.CSCharFunction(str)
|
||||
}
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CSCharFunction(swig_p.SwigcptrDirectorTest, str)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCSCharFunction(p DirectorTest, arg2 string) string {
|
||||
var swig_r string
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CSCharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CSCharFunction(p *_swig_DirectorDirectorTest, arg2 string) (swig_result string) {
|
||||
var swig_r string
|
||||
swig_r = p.CSCharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCharFunction interface {
|
||||
CharFunction(*byte) *byte
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CharFunction(_swig_ptr SwigcptrDirectorTest, _ *byte) (_swig_ret *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CharFunction(buffer *byte) *byte {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCharFunction); swig_ok {
|
||||
return swig_g.CharFunction(buffer)
|
||||
}
|
||||
var swig_r *byte
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CharFunction(swig_p.SwigcptrDirectorTest, buffer)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCharFunction(p DirectorTest, arg2 *byte) *byte {
|
||||
var swig_r *byte
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CharFunction(p *_swig_DirectorDirectorTest, arg2 *byte) (swig_result *byte) {
|
||||
var swig_r *byte
|
||||
swig_r = p.CharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
type _swig_DirectorInterfaceDirectorTestCCharFunction interface {
|
||||
CCharFunction(*byte) *byte
|
||||
}
|
||||
|
||||
var _wrap__swig_DirectorDirectorTest_upcall_CCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap__swig_DirectorDirectorTest_upcall_CCharFunction(_swig_ptr SwigcptrDirectorTest, _ *byte) (_swig_ret *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))
|
||||
_cgo_runtime_cgocall(_wrap__swig_DirectorDirectorTest_upcall_CCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (swig_p *_swig_DirectorDirectorTest) CCharFunction(buffer *byte) *byte {
|
||||
if swig_g, swig_ok := swig_p.v.(_swig_DirectorInterfaceDirectorTestCCharFunction); swig_ok {
|
||||
return swig_g.CCharFunction(buffer)
|
||||
}
|
||||
var swig_r *byte
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharFunction(swig_p.SwigcptrDirectorTest, buffer)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func DirectorDirectorTestCCharFunction(p DirectorTest, arg2 *byte) *byte {
|
||||
var swig_r *byte
|
||||
swig_r = _swig_wrap__swig_DirectorDirectorTest_upcall_CCharFunction(p.(*_swig_DirectorDirectorTest).SwigcptrDirectorTest, arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
func Swig_DirectorDirectorTest_callback_CCharFunction(p *_swig_DirectorDirectorTest, arg2 *byte) (swig_result *byte) {
|
||||
var swig_r *byte
|
||||
swig_r = p.CCharFunction(arg2)
|
||||
return swig_r
|
||||
}
|
||||
|
||||
var _wrap_DeleteDirectorDirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DeleteDirectorDirectorTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DeleteDirectorDirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDirectorDirectorTest(arg1 DirectorTest) {
|
||||
_swig_wrap_DeleteDirectorDirectorTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func Swiggo_DeleteDirector_DirectorTest(p *_swig_DirectorDirectorTest) {
|
||||
p.SwigcptrDirectorTest = 0
|
||||
}
|
||||
|
||||
type SwigcptrDirectorTest uintptr
|
||||
|
||||
func (p SwigcptrDirectorTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDirectorTest) SwigIsDirectorTest() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDirectorTest) DirectorInterface() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_UCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_UCharFunction(base SwigcptrDirectorTest, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_UCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) UCharFunction(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_DirectorTest_UCharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_SCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_SCharFunction(base SwigcptrDirectorTest, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_SCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) SCharFunction(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_DirectorTest_SCharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CUCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CUCharFunction(base SwigcptrDirectorTest, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CUCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CUCharFunction(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_DirectorTest_CUCharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CSCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CSCharFunction(base SwigcptrDirectorTest, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CSCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CSCharFunction(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_DirectorTest_CSCharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CharFunction(base SwigcptrDirectorTest, _ *byte) (_ *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CharFunction(arg2 *byte) (_swig_ret *byte) {
|
||||
return _swig_wrap_DirectorTest_CharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_DirectorTest_CCharFunction unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DirectorTest_CCharFunction(base SwigcptrDirectorTest, _ *byte) (_ *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DirectorTest_CCharFunction, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDirectorTest) CCharFunction(arg2 *byte) (_swig_ret *byte) {
|
||||
return _swig_wrap_DirectorTest_CCharFunction(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_DirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_DirectorTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_DirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDirectorTest(arg1 DirectorTest) {
|
||||
_swig_wrap_delete_DirectorTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_DirectorTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_DirectorTest() (base SwigcptrDirectorTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_DirectorTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDirectorTest() (_swig_ret DirectorTest) {
|
||||
return _swig_wrap_new_DirectorTest()
|
||||
}
|
||||
|
||||
type DirectorTest interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDirectorTest()
|
||||
DirectorInterface() interface{}
|
||||
UCharFunction(arg2 string) (_swig_ret string)
|
||||
SCharFunction(arg2 string) (_swig_ret string)
|
||||
CUCharFunction(arg2 string) (_swig_ret string)
|
||||
CSCharFunction(arg2 string) (_swig_ret string)
|
||||
CharFunction(arg2 *byte) (_swig_ret *byte)
|
||||
CCharFunction(arg2 *byte) (_swig_ret *byte)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrSwigDirector_DirectorTest uintptr
|
||||
type SwigDirector_DirectorTest interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrSwigDirector_DirectorTest) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../apply_strings.i
|
||||
|
||||
#ifndef SWIG_apply_strings_WRAP_H_
|
||||
#define SWIG_apply_strings_WRAP_H_
|
||||
|
||||
class SwigDirector_DirectorTest : public DirectorTest
|
||||
{
|
||||
public:
|
||||
SwigDirector_DirectorTest(void *swig_p);
|
||||
UCharPtr _swig_upcall_UCharFunction(UCharPtr str) {
|
||||
return DirectorTest::UCharFunction(str);
|
||||
}
|
||||
virtual UCharPtr UCharFunction(UCharPtr str);
|
||||
SCharPtr _swig_upcall_SCharFunction(SCharPtr str) {
|
||||
return DirectorTest::SCharFunction(str);
|
||||
}
|
||||
virtual SCharPtr SCharFunction(SCharPtr str);
|
||||
CUCharPtr _swig_upcall_CUCharFunction(CUCharPtr str) {
|
||||
return DirectorTest::CUCharFunction(str);
|
||||
}
|
||||
virtual CUCharPtr CUCharFunction(CUCharPtr str);
|
||||
CSCharPtr _swig_upcall_CSCharFunction(CSCharPtr str) {
|
||||
return DirectorTest::CSCharFunction(str);
|
||||
}
|
||||
virtual CSCharPtr CSCharFunction(CSCharPtr str);
|
||||
CharPtr _swig_upcall_CharFunction(CharPtr buffer) {
|
||||
return DirectorTest::CharFunction(buffer);
|
||||
}
|
||||
virtual CharPtr CharFunction(CharPtr buffer);
|
||||
CCharPtr _swig_upcall_CCharFunction(CCharPtr buffer) {
|
||||
return DirectorTest::CCharFunction(buffer);
|
||||
}
|
||||
virtual CCharPtr CCharFunction(CCharPtr buffer);
|
||||
virtual ~SwigDirector_DirectorTest();
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../argout.i
|
||||
|
||||
package argout
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_new_intp unsafe.Pointer
|
||||
|
||||
func New_intp() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_new_intp, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_copy_intp unsafe.Pointer
|
||||
|
||||
func Copy_intp(arg1 int) (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_copy_intp, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_delete_intp unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_intp(base *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_intp, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Delete_intp(arg1 *int) {
|
||||
_swig_wrap_delete_intp(arg1)
|
||||
}
|
||||
|
||||
var _wrap_intp_assign unsafe.Pointer
|
||||
|
||||
func _swig_wrap_intp_assign(base *int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_intp_assign, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Intp_assign(arg1 *int, arg2 int) {
|
||||
_swig_wrap_intp_assign(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_intp_value unsafe.Pointer
|
||||
|
||||
func Intp_value(arg1 *int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_intp_value, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_incp unsafe.Pointer
|
||||
|
||||
func Incp(arg1 *int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_incp, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_incr unsafe.Pointer
|
||||
|
||||
func Incr(arg1 *int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_incr, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_inctr unsafe.Pointer
|
||||
|
||||
func Inctr(arg1 *int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_inctr, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_voidhandle unsafe.Pointer
|
||||
|
||||
func _swig_wrap_voidhandle(base *uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_voidhandle, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Voidhandle(arg1 *uintptr) {
|
||||
_swig_wrap_voidhandle(arg1)
|
||||
}
|
||||
|
||||
var _wrap_handle unsafe.Pointer
|
||||
|
||||
func Handle(arg1 uintptr) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_handle, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,586 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../array_member.i
|
||||
|
||||
package array_member
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_text_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_text_set(base SwigcptrFoo, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_text_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetText(arg2 string) {
|
||||
_swig_wrap_Foo_text_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_text_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_text_get(base SwigcptrFoo) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_text_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetText() (_swig_ret string) {
|
||||
return _swig_wrap_Foo_text_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_data_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_data_set(base SwigcptrFoo, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_data_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetData(arg2 *int) {
|
||||
_swig_wrap_Foo_data_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_data_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_data_get(base SwigcptrFoo) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_data_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetData() (_swig_ret *int) {
|
||||
return _swig_wrap_Foo_data_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetText(arg2 string)
|
||||
GetText() (_swig_ret string)
|
||||
SetData(arg2 *int)
|
||||
GetData() (_swig_ret *int)
|
||||
}
|
||||
|
||||
var _wrap_global_data_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_data_set(base *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_data_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobal_data(arg1 *int) {
|
||||
_swig_wrap_global_data_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_global_data_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_data() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_data_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_set_value unsafe.Pointer
|
||||
|
||||
func _swig_wrap_set_value(base *int, _ int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_set_value, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Set_value(arg1 *int, arg2 int, arg3 int) {
|
||||
_swig_wrap_set_value(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_get_value unsafe.Pointer
|
||||
|
||||
func Get_value(arg1 *int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_get_value, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrMaterial uintptr
|
||||
|
||||
func (p SwigcptrMaterial) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMaterial) SwigIsMaterial() {
|
||||
}
|
||||
|
||||
var _wrap_new_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Material() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMaterial() (_swig_ret Material) {
|
||||
return _swig_wrap_new_Material()
|
||||
}
|
||||
|
||||
var _wrap_delete_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Material(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMaterial(arg1 Material) {
|
||||
_swig_wrap_delete_Material(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Material interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMaterial()
|
||||
}
|
||||
|
||||
type SwigcptrRayPacketData uintptr
|
||||
|
||||
func (p SwigcptrRayPacketData) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrRayPacketData) SwigIsRayPacketData() {
|
||||
}
|
||||
|
||||
var _wrap_Size_RayPacketData unsafe.Pointer
|
||||
|
||||
func _swig_getRayPacketData_Size_RayPacketData() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Size_RayPacketData, _swig_p)
|
||||
return
|
||||
}
|
||||
var RayPacketDataSize int = _swig_getRayPacketData_Size_RayPacketData()
|
||||
var _wrap_RayPacketData_chitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_chitMat_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_chitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetChitMat(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_chitMat_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_chitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_chitMat_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_chitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetChitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_chitMat_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_val_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_val_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_val_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetHitMat_val(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_hitMat_val_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_val_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_val_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_val_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetHitMat_val() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_hitMat_val_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetHitMat(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_hitMat_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetHitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_hitMat_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_chitMat2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_chitMat2_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_chitMat2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetChitMat2(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_chitMat2_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_chitMat2_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_chitMat2_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_chitMat2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetChitMat2() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_chitMat2_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_val2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_val2_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_val2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetHitMat_val2(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_hitMat_val2_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat_val2_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat_val2_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat_val2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetHitMat_val2() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_hitMat_val2_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat2_set(base SwigcptrRayPacketData, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) SetHitMat2(arg2 Material) {
|
||||
_swig_wrap_RayPacketData_hitMat2_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_RayPacketData_hitMat2_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_RayPacketData_hitMat2_get(base SwigcptrRayPacketData) (_ SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_RayPacketData_hitMat2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrRayPacketData) GetHitMat2() (_swig_ret Material) {
|
||||
return _swig_wrap_RayPacketData_hitMat2_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_RayPacketData unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_RayPacketData() (base SwigcptrRayPacketData) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_RayPacketData, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewRayPacketData() (_swig_ret RayPacketData) {
|
||||
return _swig_wrap_new_RayPacketData()
|
||||
}
|
||||
|
||||
var _wrap_delete_RayPacketData unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_RayPacketData(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_RayPacketData, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteRayPacketData(arg1 RayPacketData) {
|
||||
_swig_wrap_delete_RayPacketData(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type RayPacketData interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsRayPacketData()
|
||||
SetChitMat(arg2 Material)
|
||||
GetChitMat() (_swig_ret Material)
|
||||
SetHitMat_val(arg2 Material)
|
||||
GetHitMat_val() (_swig_ret Material)
|
||||
SetHitMat(arg2 Material)
|
||||
GetHitMat() (_swig_ret Material)
|
||||
SetChitMat2(arg2 Material)
|
||||
GetChitMat2() (_swig_ret Material)
|
||||
SetHitMat_val2(arg2 Material)
|
||||
GetHitMat_val2() (_swig_ret Material)
|
||||
SetHitMat2(arg2 Material)
|
||||
GetHitMat2() (_swig_ret Material)
|
||||
}
|
||||
|
||||
const BUFF_LEN int = 12
|
||||
type SwigcptrMyBuff uintptr
|
||||
|
||||
func (p SwigcptrMyBuff) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMyBuff) SwigIsMyBuff() {
|
||||
}
|
||||
|
||||
var _wrap_MyBuff_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MyBuff_i_set(base SwigcptrMyBuff, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MyBuff_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMyBuff) SetI(arg2 int) {
|
||||
_swig_wrap_MyBuff_i_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_MyBuff_i_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MyBuff_i_get(base SwigcptrMyBuff) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MyBuff_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMyBuff) GetI() (_swig_ret int) {
|
||||
return _swig_wrap_MyBuff_i_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_MyBuff_x_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MyBuff_x_set(base SwigcptrMyBuff, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MyBuff_x_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMyBuff) SetX(arg2 string) {
|
||||
_swig_wrap_MyBuff_x_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_MyBuff_x_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MyBuff_x_get(base SwigcptrMyBuff) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MyBuff_x_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMyBuff) GetX() (_swig_ret string) {
|
||||
return _swig_wrap_MyBuff_x_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_MyBuff unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_MyBuff() (base SwigcptrMyBuff) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_MyBuff, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMyBuff() (_swig_ret MyBuff) {
|
||||
return _swig_wrap_new_MyBuff()
|
||||
}
|
||||
|
||||
var _wrap_delete_MyBuff unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_MyBuff(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_MyBuff, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMyBuff(arg1 MyBuff) {
|
||||
_swig_wrap_delete_MyBuff(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type MyBuff interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMyBuff()
|
||||
SetI(arg2 int)
|
||||
GetI() (_swig_ret int)
|
||||
SetX(arg2 string)
|
||||
GetX() (_swig_ret string)
|
||||
}
|
||||
|
||||
type SwigcptrMySBuff uintptr
|
||||
|
||||
func (p SwigcptrMySBuff) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMySBuff) SwigIsMySBuff() {
|
||||
}
|
||||
|
||||
var _wrap_MySBuff_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MySBuff_i_set(base SwigcptrMySBuff, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MySBuff_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMySBuff) SetI(arg2 int) {
|
||||
_swig_wrap_MySBuff_i_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_MySBuff_i_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MySBuff_i_get(base SwigcptrMySBuff) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MySBuff_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMySBuff) GetI() (_swig_ret int) {
|
||||
return _swig_wrap_MySBuff_i_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_MySBuff_x_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MySBuff_x_set(base SwigcptrMySBuff, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MySBuff_x_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMySBuff) SetX(arg2 string) {
|
||||
_swig_wrap_MySBuff_x_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_MySBuff_x_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_MySBuff_x_get(base SwigcptrMySBuff) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_MySBuff_x_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrMySBuff) GetX() (_swig_ret string) {
|
||||
return _swig_wrap_MySBuff_x_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_MySBuff unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_MySBuff() (base SwigcptrMySBuff) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_MySBuff, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMySBuff() (_swig_ret MySBuff) {
|
||||
return _swig_wrap_new_MySBuff()
|
||||
}
|
||||
|
||||
var _wrap_delete_MySBuff unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_MySBuff(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_MySBuff, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMySBuff(arg1 MySBuff) {
|
||||
_swig_wrap_delete_MySBuff(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type MySBuff interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMySBuff()
|
||||
SetI(arg2 int)
|
||||
GetI() (_swig_ret int)
|
||||
SetX(arg2 string)
|
||||
GetX() (_swig_ret string)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,328 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../array_typedef_memberin.i
|
||||
|
||||
package array_typedef_memberin
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrExampleDetail uintptr
|
||||
|
||||
func (p SwigcptrExampleDetail) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrExampleDetail) SwigIsExampleDetail() {
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_node_list_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_node_list_set(base SwigcptrExampleDetail, _ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_node_list_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) SetNode_list(arg2 *int16) {
|
||||
_swig_wrap_ExampleDetail_node_list_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_node_list_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_node_list_get(base SwigcptrExampleDetail) (_ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_node_list_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) GetNode_list() (_swig_ret *int16) {
|
||||
return _swig_wrap_ExampleDetail_node_list_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_node_list2_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_node_list2_get(base SwigcptrExampleDetail) (_ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_node_list2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) GetNode_list2() (_swig_ret *int16) {
|
||||
return _swig_wrap_ExampleDetail_node_list2_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_node_list3_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_node_list3_get(base SwigcptrExampleDetail) (_ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_node_list3_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) GetNode_list3() (_swig_ret *int16) {
|
||||
return _swig_wrap_ExampleDetail_node_list3_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn1(base SwigcptrExampleDetail, _ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn1(arg2 *int16) {
|
||||
_swig_wrap_ExampleDetail_fn1(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn2(base SwigcptrExampleDetail, _ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn2(arg2 *int16) {
|
||||
_swig_wrap_ExampleDetail_fn2(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn3(base SwigcptrExampleDetail, _ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn3(arg2 *int16) {
|
||||
_swig_wrap_ExampleDetail_fn3(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn4(base SwigcptrExampleDetail, _ **int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn4(arg2 **int16) {
|
||||
_swig_wrap_ExampleDetail_fn4(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn5(base SwigcptrExampleDetail, _ **int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn5(arg2 **int16) {
|
||||
_swig_wrap_ExampleDetail_fn5(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn6 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn6(base SwigcptrExampleDetail, _ **int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn6, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn6(arg2 **int16) {
|
||||
_swig_wrap_ExampleDetail_fn6(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn7 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn7(base SwigcptrExampleDetail, _ ***int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn7, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn7(arg2 ***int16) {
|
||||
_swig_wrap_ExampleDetail_fn7(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn8 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn8(base SwigcptrExampleDetail, _ ***int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn8, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn8(arg2 ***int16) {
|
||||
_swig_wrap_ExampleDetail_fn8(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ExampleDetail_fn9 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ExampleDetail_fn9(base SwigcptrExampleDetail, _ ***int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ExampleDetail_fn9, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrExampleDetail) Fn9(arg2 ***int16) {
|
||||
_swig_wrap_ExampleDetail_fn9(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_ExampleDetail unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_ExampleDetail() (base SwigcptrExampleDetail) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_ExampleDetail, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewExampleDetail() (_swig_ret ExampleDetail) {
|
||||
return _swig_wrap_new_ExampleDetail()
|
||||
}
|
||||
|
||||
var _wrap_delete_ExampleDetail unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_ExampleDetail(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_ExampleDetail, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteExampleDetail(arg1 ExampleDetail) {
|
||||
_swig_wrap_delete_ExampleDetail(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type ExampleDetail interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsExampleDetail()
|
||||
SetNode_list(arg2 *int16)
|
||||
GetNode_list() (_swig_ret *int16)
|
||||
GetNode_list2() (_swig_ret *int16)
|
||||
GetNode_list3() (_swig_ret *int16)
|
||||
Fn1(arg2 *int16)
|
||||
Fn2(arg2 *int16)
|
||||
Fn3(arg2 *int16)
|
||||
Fn4(arg2 **int16)
|
||||
Fn5(arg2 **int16)
|
||||
Fn6(arg2 **int16)
|
||||
Fn7(arg2 ***int16)
|
||||
Fn8(arg2 ***int16)
|
||||
Fn9(arg2 ***int16)
|
||||
}
|
||||
|
||||
var _wrap_test_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_1(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_1(arg1 **int) {
|
||||
_swig_wrap_test_1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_2(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_2(arg1 **int) {
|
||||
_swig_wrap_test_2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_3(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_3(arg1 **int) {
|
||||
_swig_wrap_test_3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_4(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_4(arg1 **int) {
|
||||
_swig_wrap_test_4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_5(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_5(arg1 **int) {
|
||||
_swig_wrap_test_5(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_3r unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_3r(base ***int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_3r, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_3r(arg1 ***int) {
|
||||
_swig_wrap_test_3r(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_4r unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_4r(base ***int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_4r, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_4r(arg1 ***int) {
|
||||
_swig_wrap_test_4r(arg1)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrayref.i
|
||||
|
||||
package arrayref
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_foo(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Foo(arg1 **int) {
|
||||
_swig_wrap_foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_bar(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Bar(arg1 **int) {
|
||||
_swig_wrap_bar(arg1)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,750 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrays.i
|
||||
|
||||
package arrays
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const ARRAY_LEN int = 2
|
||||
type Finger int
|
||||
var _wrap_One unsafe.Pointer
|
||||
|
||||
func _swig_getOne() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_One, _swig_p)
|
||||
return
|
||||
}
|
||||
var One int = _swig_getOne()
|
||||
var _wrap_Two unsafe.Pointer
|
||||
|
||||
func _swig_getTwo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Two, _swig_p)
|
||||
return
|
||||
}
|
||||
var Two int = _swig_getTwo()
|
||||
var _wrap_Three unsafe.Pointer
|
||||
|
||||
func _swig_getThree() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Three, _swig_p)
|
||||
return
|
||||
}
|
||||
var Three int = _swig_getThree()
|
||||
var _wrap_Four unsafe.Pointer
|
||||
|
||||
func _swig_getFour() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Four, _swig_p)
|
||||
return
|
||||
}
|
||||
var Four int = _swig_getFour()
|
||||
var _wrap_Five unsafe.Pointer
|
||||
|
||||
func _swig_getFive() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Five, _swig_p)
|
||||
return
|
||||
}
|
||||
var Five int = _swig_getFive()
|
||||
type SwigcptrSimpleStruct uintptr
|
||||
|
||||
func (p SwigcptrSimpleStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSimpleStruct) SwigIsSimpleStruct() {
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_set(base SwigcptrSimpleStruct, _ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) SetDouble_field(arg2 float64) {
|
||||
_swig_wrap_SimpleStruct_double_field_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_get(base SwigcptrSimpleStruct) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) GetDouble_field() (_swig_ret float64) {
|
||||
return _swig_wrap_SimpleStruct_double_field_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_SimpleStruct() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSimpleStruct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_new_SimpleStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_SimpleStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSimpleStruct(arg1 SimpleStruct) {
|
||||
_swig_wrap_delete_SimpleStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SimpleStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSimpleStruct()
|
||||
SetDouble_field(arg2 float64)
|
||||
GetDouble_field() (_swig_ret float64)
|
||||
}
|
||||
|
||||
type SwigcptrArrayStruct uintptr
|
||||
|
||||
func (p SwigcptrArrayStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrArrayStruct) SwigIsArrayStruct() {
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_c_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_c_set(base SwigcptrArrayStruct, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_c_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_c(arg2 string) {
|
||||
_swig_wrap_ArrayStruct_array_c_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_c_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_c_get(base SwigcptrArrayStruct) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_c_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_c() (_swig_ret string) {
|
||||
return _swig_wrap_ArrayStruct_array_c_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_sc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_sc_set(base SwigcptrArrayStruct, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_sc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_sc(arg2 string) {
|
||||
_swig_wrap_ArrayStruct_array_sc_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_sc_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_sc_get(base SwigcptrArrayStruct) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_sc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_sc() (_swig_ret string) {
|
||||
return _swig_wrap_ArrayStruct_array_sc_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_uc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_uc_set(base SwigcptrArrayStruct, _ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_uc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_uc(arg2 string) {
|
||||
_swig_wrap_ArrayStruct_array_uc_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_uc_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_uc_get(base SwigcptrArrayStruct) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_uc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_uc() (_swig_ret string) {
|
||||
return _swig_wrap_ArrayStruct_array_uc_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_s_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_s_set(base SwigcptrArrayStruct, _ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_s_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_s(arg2 *int16) {
|
||||
_swig_wrap_ArrayStruct_array_s_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_s_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_s_get(base SwigcptrArrayStruct) (_ *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_s_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_s() (_swig_ret *int16) {
|
||||
return _swig_wrap_ArrayStruct_array_s_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_us_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_us_set(base SwigcptrArrayStruct, _ *uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_us_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_us(arg2 *uint16) {
|
||||
_swig_wrap_ArrayStruct_array_us_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_us_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_us_get(base SwigcptrArrayStruct) (_ *uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_us_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_us() (_swig_ret *uint16) {
|
||||
return _swig_wrap_ArrayStruct_array_us_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_i_set(base SwigcptrArrayStruct, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_i(arg2 *int) {
|
||||
_swig_wrap_ArrayStruct_array_i_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_i_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_i_get(base SwigcptrArrayStruct) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_i() (_swig_ret *int) {
|
||||
return _swig_wrap_ArrayStruct_array_i_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ui_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ui_set(base SwigcptrArrayStruct, _ *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ui_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_ui(arg2 *uint) {
|
||||
_swig_wrap_ArrayStruct_array_ui_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ui_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ui_get(base SwigcptrArrayStruct) (_ *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ui_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_ui() (_swig_ret *uint) {
|
||||
return _swig_wrap_ArrayStruct_array_ui_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_l_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_l_set(base SwigcptrArrayStruct, _ *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_l_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_l(arg2 *int64) {
|
||||
_swig_wrap_ArrayStruct_array_l_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_l_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_l_get(base SwigcptrArrayStruct) (_ *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_l_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_l() (_swig_ret *int64) {
|
||||
return _swig_wrap_ArrayStruct_array_l_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ul_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ul_set(base SwigcptrArrayStruct, _ *uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ul_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_ul(arg2 *uint64) {
|
||||
_swig_wrap_ArrayStruct_array_ul_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ul_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ul_get(base SwigcptrArrayStruct) (_ *uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ul_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_ul() (_swig_ret *uint64) {
|
||||
return _swig_wrap_ArrayStruct_array_ul_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ll_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ll_set(base SwigcptrArrayStruct, _ *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ll_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_ll(arg2 *int64) {
|
||||
_swig_wrap_ArrayStruct_array_ll_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ll_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ll_get(base SwigcptrArrayStruct) (_ *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ll_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_ll() (_swig_ret *int64) {
|
||||
return _swig_wrap_ArrayStruct_array_ll_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_f_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_f_set(base SwigcptrArrayStruct, _ *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_f_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_f(arg2 *float32) {
|
||||
_swig_wrap_ArrayStruct_array_f_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_f_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_f_get(base SwigcptrArrayStruct) (_ *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_f_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_f() (_swig_ret *float32) {
|
||||
return _swig_wrap_ArrayStruct_array_f_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_d_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_d_set(base SwigcptrArrayStruct, _ *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_d_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_d(arg2 *float64) {
|
||||
_swig_wrap_ArrayStruct_array_d_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_d_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_d_get(base SwigcptrArrayStruct) (_ *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_d_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_d() (_swig_ret *float64) {
|
||||
return _swig_wrap_ArrayStruct_array_d_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_struct_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_struct_set(base SwigcptrArrayStruct, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_struct_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_struct(arg2 SimpleStruct) {
|
||||
_swig_wrap_ArrayStruct_array_struct_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_struct_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_struct_get(base SwigcptrArrayStruct) (_ SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_struct_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_struct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_ArrayStruct_array_struct_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_structpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_structpointers_set(base SwigcptrArrayStruct, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_structpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_structpointers(arg2 SimpleStruct) {
|
||||
_swig_wrap_ArrayStruct_array_structpointers_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_structpointers_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_structpointers_get(base SwigcptrArrayStruct) (_ SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_structpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_structpointers() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_ArrayStruct_array_structpointers_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ipointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ipointers_set(base SwigcptrArrayStruct, _ **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ipointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_ipointers(arg2 **int) {
|
||||
_swig_wrap_ArrayStruct_array_ipointers_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_ipointers_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_ipointers_get(base SwigcptrArrayStruct) (_ **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_ipointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_ipointers() (_swig_ret **int) {
|
||||
return _swig_wrap_ArrayStruct_array_ipointers_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_enum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_enum_set(base SwigcptrArrayStruct, _ *Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_enum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_enum(arg2 *Finger) {
|
||||
_swig_wrap_ArrayStruct_array_enum_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_enum_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_enum_get(base SwigcptrArrayStruct) (_ *Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_enum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_enum() (_swig_ret *Finger) {
|
||||
return _swig_wrap_ArrayStruct_array_enum_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_enumpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_enumpointers_set(base SwigcptrArrayStruct, _ **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_enumpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) SetArray_enumpointers(arg2 **Finger) {
|
||||
_swig_wrap_ArrayStruct_array_enumpointers_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_enumpointers_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_enumpointers_get(base SwigcptrArrayStruct) (_ **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_enumpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_enumpointers() (_swig_ret **Finger) {
|
||||
return _swig_wrap_ArrayStruct_array_enumpointers_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_ArrayStruct_array_const_i_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_ArrayStruct_array_const_i_get(base SwigcptrArrayStruct) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_ArrayStruct_array_const_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrArrayStruct) GetArray_const_i() (_swig_ret *int) {
|
||||
return _swig_wrap_ArrayStruct_array_const_i_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_ArrayStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_ArrayStruct() (base SwigcptrArrayStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_ArrayStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewArrayStruct() (_swig_ret ArrayStruct) {
|
||||
return _swig_wrap_new_ArrayStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_ArrayStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_ArrayStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_ArrayStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteArrayStruct(arg1 ArrayStruct) {
|
||||
_swig_wrap_delete_ArrayStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type ArrayStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsArrayStruct()
|
||||
SetArray_c(arg2 string)
|
||||
GetArray_c() (_swig_ret string)
|
||||
SetArray_sc(arg2 string)
|
||||
GetArray_sc() (_swig_ret string)
|
||||
SetArray_uc(arg2 string)
|
||||
GetArray_uc() (_swig_ret string)
|
||||
SetArray_s(arg2 *int16)
|
||||
GetArray_s() (_swig_ret *int16)
|
||||
SetArray_us(arg2 *uint16)
|
||||
GetArray_us() (_swig_ret *uint16)
|
||||
SetArray_i(arg2 *int)
|
||||
GetArray_i() (_swig_ret *int)
|
||||
SetArray_ui(arg2 *uint)
|
||||
GetArray_ui() (_swig_ret *uint)
|
||||
SetArray_l(arg2 *int64)
|
||||
GetArray_l() (_swig_ret *int64)
|
||||
SetArray_ul(arg2 *uint64)
|
||||
GetArray_ul() (_swig_ret *uint64)
|
||||
SetArray_ll(arg2 *int64)
|
||||
GetArray_ll() (_swig_ret *int64)
|
||||
SetArray_f(arg2 *float32)
|
||||
GetArray_f() (_swig_ret *float32)
|
||||
SetArray_d(arg2 *float64)
|
||||
GetArray_d() (_swig_ret *float64)
|
||||
SetArray_struct(arg2 SimpleStruct)
|
||||
GetArray_struct() (_swig_ret SimpleStruct)
|
||||
SetArray_structpointers(arg2 SimpleStruct)
|
||||
GetArray_structpointers() (_swig_ret SimpleStruct)
|
||||
SetArray_ipointers(arg2 **int)
|
||||
GetArray_ipointers() (_swig_ret **int)
|
||||
SetArray_enum(arg2 *Finger)
|
||||
GetArray_enum() (_swig_ret *Finger)
|
||||
SetArray_enumpointers(arg2 **Finger)
|
||||
GetArray_enumpointers() (_swig_ret **Finger)
|
||||
GetArray_const_i() (_swig_ret *int)
|
||||
}
|
||||
|
||||
var _wrap_fn_taking_arrays unsafe.Pointer
|
||||
|
||||
func _swig_wrap_fn_taking_arrays(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_fn_taking_arrays, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Fn_taking_arrays(arg1 SimpleStruct) {
|
||||
_swig_wrap_fn_taking_arrays(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_newintpointer unsafe.Pointer
|
||||
|
||||
func Newintpointer() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_newintpointer, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_setintfrompointer unsafe.Pointer
|
||||
|
||||
func _swig_wrap_setintfrompointer(base *int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_setintfrompointer, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Setintfrompointer(arg1 *int, arg2 int) {
|
||||
_swig_wrap_setintfrompointer(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_getintfrompointer unsafe.Pointer
|
||||
|
||||
func Getintfrompointer(arg1 *int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_getintfrompointer, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_pointer_func unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_pointer_func(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_pointer_func, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Array_pointer_func(arg1 **int) {
|
||||
_swig_wrap_array_pointer_func(arg1)
|
||||
}
|
||||
|
||||
type SwigcptrCartPoseData_t uintptr
|
||||
|
||||
func (p SwigcptrCartPoseData_t) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrCartPoseData_t) SwigIsCartPoseData_t() {
|
||||
}
|
||||
|
||||
var _wrap_CartPoseData_t_p_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_CartPoseData_t_p_set(base SwigcptrCartPoseData_t, _ *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_CartPoseData_t_p_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrCartPoseData_t) SetP(arg2 *float32) {
|
||||
_swig_wrap_CartPoseData_t_p_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_CartPoseData_t_p_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_CartPoseData_t_p_get(base SwigcptrCartPoseData_t) (_ *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_CartPoseData_t_p_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrCartPoseData_t) GetP() (_swig_ret *float32) {
|
||||
return _swig_wrap_CartPoseData_t_p_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_CartPoseData_t unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_CartPoseData_t() (base SwigcptrCartPoseData_t) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_CartPoseData_t, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewCartPoseData_t() (_swig_ret CartPoseData_t) {
|
||||
return _swig_wrap_new_CartPoseData_t()
|
||||
}
|
||||
|
||||
var _wrap_delete_CartPoseData_t unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_CartPoseData_t(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_CartPoseData_t, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteCartPoseData_t(arg1 CartPoseData_t) {
|
||||
_swig_wrap_delete_CartPoseData_t(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type CartPoseData_t interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsCartPoseData_t()
|
||||
SetP(arg2 *float32)
|
||||
GetP() (_swig_ret *float32)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,292 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrays_dimensionless.i
|
||||
|
||||
package arrays_dimensionless
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_globalints_get unsafe.Pointer
|
||||
|
||||
func GetGlobalints() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_globalints_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_constglobalints_get unsafe.Pointer
|
||||
|
||||
func GetConstglobalints() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_constglobalints_get, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_ints_get unsafe.Pointer
|
||||
|
||||
func GetBarInts() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_ints_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
}
|
||||
|
||||
var _wrap_arr_bool unsafe.Pointer
|
||||
|
||||
func Arr_bool(arg1 *bool, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_bool, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_char unsafe.Pointer
|
||||
|
||||
func Arr_char(arg1 string, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_char, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_schar unsafe.Pointer
|
||||
|
||||
func Arr_schar(arg1 string, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_schar, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_uchar unsafe.Pointer
|
||||
|
||||
func Arr_uchar(arg1 string, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_uchar, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_short unsafe.Pointer
|
||||
|
||||
func Arr_short(arg1 *int16, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_short, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_ushort unsafe.Pointer
|
||||
|
||||
func Arr_ushort(arg1 *uint16, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_ushort, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_int unsafe.Pointer
|
||||
|
||||
func Arr_int(arg1 *int, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_int, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_uint unsafe.Pointer
|
||||
|
||||
func Arr_uint(arg1 *uint, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_uint, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_long unsafe.Pointer
|
||||
|
||||
func Arr_long(arg1 *int64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_long, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_ulong unsafe.Pointer
|
||||
|
||||
func Arr_ulong(arg1 *uint64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_ulong, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_ll unsafe.Pointer
|
||||
|
||||
func Arr_ll(arg1 *int64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_ll, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_ull unsafe.Pointer
|
||||
|
||||
func Arr_ull(arg1 *uint64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_ull, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_float unsafe.Pointer
|
||||
|
||||
func Arr_float(arg1 *float32, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_float, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_arr_double unsafe.Pointer
|
||||
|
||||
func Arr_double(arg1 *float64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_arr_double, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_bool unsafe.Pointer
|
||||
|
||||
func Ptr_bool(arg1 *bool, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_bool, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_char unsafe.Pointer
|
||||
|
||||
func Ptr_char(arg1 *byte, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_char, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_schar unsafe.Pointer
|
||||
|
||||
func Ptr_schar(arg1 *int8, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_schar, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_uchar unsafe.Pointer
|
||||
|
||||
func Ptr_uchar(arg1 *byte, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_uchar, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_short unsafe.Pointer
|
||||
|
||||
func Ptr_short(arg1 *int16, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_short, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_ushort unsafe.Pointer
|
||||
|
||||
func Ptr_ushort(arg1 *uint16, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_ushort, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_int unsafe.Pointer
|
||||
|
||||
func Ptr_int(arg1 *int, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_int, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_uint unsafe.Pointer
|
||||
|
||||
func Ptr_uint(arg1 *uint, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_uint, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_long unsafe.Pointer
|
||||
|
||||
func Ptr_long(arg1 *int64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_long, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_ulong unsafe.Pointer
|
||||
|
||||
func Ptr_ulong(arg1 *uint64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_ulong, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_ll unsafe.Pointer
|
||||
|
||||
func Ptr_ll(arg1 *int64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_ll, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_ull unsafe.Pointer
|
||||
|
||||
func Ptr_ull(arg1 *uint64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_ull, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_float unsafe.Pointer
|
||||
|
||||
func Ptr_float(arg1 *float32, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_float, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ptr_double unsafe.Pointer
|
||||
|
||||
func Ptr_double(arg1 *float64, arg2 int) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_ptr_double, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,729 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrays_global.i
|
||||
|
||||
package arrays_global
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const ARRAY_LEN int = 2
|
||||
type Finger int
|
||||
var _wrap_One unsafe.Pointer
|
||||
|
||||
func _swig_getOne() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_One, _swig_p)
|
||||
return
|
||||
}
|
||||
var One int = _swig_getOne()
|
||||
var _wrap_Two unsafe.Pointer
|
||||
|
||||
func _swig_getTwo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Two, _swig_p)
|
||||
return
|
||||
}
|
||||
var Two int = _swig_getTwo()
|
||||
var _wrap_Three unsafe.Pointer
|
||||
|
||||
func _swig_getThree() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Three, _swig_p)
|
||||
return
|
||||
}
|
||||
var Three int = _swig_getThree()
|
||||
var _wrap_Four unsafe.Pointer
|
||||
|
||||
func _swig_getFour() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Four, _swig_p)
|
||||
return
|
||||
}
|
||||
var Four int = _swig_getFour()
|
||||
var _wrap_Five unsafe.Pointer
|
||||
|
||||
func _swig_getFive() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Five, _swig_p)
|
||||
return
|
||||
}
|
||||
var Five int = _swig_getFive()
|
||||
type SwigcptrSimpleStruct uintptr
|
||||
|
||||
func (p SwigcptrSimpleStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSimpleStruct) SwigIsSimpleStruct() {
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_set(base SwigcptrSimpleStruct, _ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) SetDouble_field(arg2 float64) {
|
||||
_swig_wrap_SimpleStruct_double_field_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_get(base SwigcptrSimpleStruct) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) GetDouble_field() (_swig_ret float64) {
|
||||
return _swig_wrap_SimpleStruct_double_field_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_SimpleStruct() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSimpleStruct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_new_SimpleStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_SimpleStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSimpleStruct(arg1 SimpleStruct) {
|
||||
_swig_wrap_delete_SimpleStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SimpleStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSimpleStruct()
|
||||
SetDouble_field(arg2 float64)
|
||||
GetDouble_field() (_swig_ret float64)
|
||||
}
|
||||
|
||||
var _wrap_array_c_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_c_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_c_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_c(arg1 string) {
|
||||
_swig_wrap_array_c_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_c_get unsafe.Pointer
|
||||
|
||||
func GetArray_c() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_c_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_sc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_sc_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_sc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_sc(arg1 string) {
|
||||
_swig_wrap_array_sc_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_sc_get unsafe.Pointer
|
||||
|
||||
func GetArray_sc() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_sc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_uc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_uc_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_uc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_uc(arg1 string) {
|
||||
_swig_wrap_array_uc_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_uc_get unsafe.Pointer
|
||||
|
||||
func GetArray_uc() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_uc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_s_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_s_set(base *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_s_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_s(arg1 *int16) {
|
||||
_swig_wrap_array_s_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_s_get unsafe.Pointer
|
||||
|
||||
func GetArray_s() (_swig_ret *int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_s_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_us_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_us_set(base *uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_us_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_us(arg1 *uint16) {
|
||||
_swig_wrap_array_us_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_us_get unsafe.Pointer
|
||||
|
||||
func GetArray_us() (_swig_ret *uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_us_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_i_set(base *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_i(arg1 *int) {
|
||||
_swig_wrap_array_i_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_i_get unsafe.Pointer
|
||||
|
||||
func GetArray_i() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ui_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ui_set(base *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ui_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ui(arg1 *uint) {
|
||||
_swig_wrap_array_ui_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ui_get unsafe.Pointer
|
||||
|
||||
func GetArray_ui() (_swig_ret *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ui_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_l_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_l_set(base *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_l_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_l(arg1 *int64) {
|
||||
_swig_wrap_array_l_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_l_get unsafe.Pointer
|
||||
|
||||
func GetArray_l() (_swig_ret *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_l_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ul_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ul_set(base *uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ul_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ul(arg1 *uint64) {
|
||||
_swig_wrap_array_ul_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ul_get unsafe.Pointer
|
||||
|
||||
func GetArray_ul() (_swig_ret *uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ul_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ll_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ll_set(base *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ll_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ll(arg1 *int64) {
|
||||
_swig_wrap_array_ll_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ll_get unsafe.Pointer
|
||||
|
||||
func GetArray_ll() (_swig_ret *int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ll_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_f_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_f_set(base *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_f_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_f(arg1 *float32) {
|
||||
_swig_wrap_array_f_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_f_get unsafe.Pointer
|
||||
|
||||
func GetArray_f() (_swig_ret *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_f_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_d_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_d_set(base *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_d_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_d(arg1 *float64) {
|
||||
_swig_wrap_array_d_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_d_get unsafe.Pointer
|
||||
|
||||
func GetArray_d() (_swig_ret *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_d_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_struct_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_struct_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_struct_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_struct(arg1 SimpleStruct) {
|
||||
_swig_wrap_array_struct_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_array_struct_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_struct_get() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_struct_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetArray_struct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_array_struct_get()
|
||||
}
|
||||
|
||||
var _wrap_array_structpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_structpointers_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_structpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_structpointers(arg1 SimpleStruct) {
|
||||
_swig_wrap_array_structpointers_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_array_structpointers_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_structpointers_get() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_structpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetArray_structpointers() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_array_structpointers_get()
|
||||
}
|
||||
|
||||
var _wrap_array_ipointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ipointers_set(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ipointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ipointers(arg1 **int) {
|
||||
_swig_wrap_array_ipointers_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ipointers_get unsafe.Pointer
|
||||
|
||||
func GetArray_ipointers() (_swig_ret **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ipointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_enum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_enum_set(base *Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_enum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_enum(arg1 *Finger) {
|
||||
_swig_wrap_array_enum_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_enum_get unsafe.Pointer
|
||||
|
||||
func GetArray_enum() (_swig_ret *Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_enum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_enumpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_enumpointers_set(base **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_enumpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_enumpointers(arg1 **Finger) {
|
||||
_swig_wrap_array_enumpointers_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_enumpointers_get unsafe.Pointer
|
||||
|
||||
func GetArray_enumpointers() (_swig_ret **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_enumpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_const_i_get unsafe.Pointer
|
||||
|
||||
func GetArray_const_i() (_swig_ret *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_const_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44a_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44a() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44a_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44b_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BeginString_FIX44b_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44b_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBeginString_FIX44b(arg1 string) {
|
||||
_swig_wrap_BeginString_FIX44b_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BeginString_FIX44b_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44b() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44b_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44c_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44c() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44c_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44d_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BeginString_FIX44d_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44d_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBeginString_FIX44d(arg1 string) {
|
||||
_swig_wrap_BeginString_FIX44d_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BeginString_FIX44d_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44d() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44d_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44e_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BeginString_FIX44e_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44e_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBeginString_FIX44e(arg1 string) {
|
||||
_swig_wrap_BeginString_FIX44e_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BeginString_FIX44e_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44e() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44e_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_BeginString_FIX44f_get unsafe.Pointer
|
||||
|
||||
func GetBeginString_FIX44f() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BeginString_FIX44f_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_a__SWIG_0 unsafe.Pointer
|
||||
|
||||
func Test_a__SWIG_0(arg1 string, arg2 string, arg3 string, arg4 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_a__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_b__SWIG_0 unsafe.Pointer
|
||||
|
||||
func Test_b__SWIG_0(arg1 string, arg2 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_b__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_a__SWIG_1 unsafe.Pointer
|
||||
|
||||
func Test_a__SWIG_1(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_a__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
func Test_a(a ...interface{}) interface{} {
|
||||
argc := len(a)
|
||||
if argc == 1 {
|
||||
return Test_a__SWIG_1(a[0].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return Test_a__SWIG_0(a[0].(string), a[1].(string), a[2].(string), a[3].(string))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_test_b__SWIG_1 unsafe.Pointer
|
||||
|
||||
func Test_b__SWIG_1(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_b__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
func Test_b(a ...interface{}) interface{} {
|
||||
argc := len(a)
|
||||
if argc == 1 {
|
||||
return Test_b__SWIG_1(a[0].(int))
|
||||
}
|
||||
if argc == 2 {
|
||||
return Test_b__SWIG_0(a[0].(string), a[1].(string))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
type SwigcptrMaterial uintptr
|
||||
|
||||
func (p SwigcptrMaterial) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMaterial) SwigIsMaterial() {
|
||||
}
|
||||
|
||||
var _wrap_new_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Material() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMaterial() (_swig_ret Material) {
|
||||
return _swig_wrap_new_Material()
|
||||
}
|
||||
|
||||
var _wrap_delete_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Material(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMaterial(arg1 Material) {
|
||||
_swig_wrap_delete_Material(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Material interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMaterial()
|
||||
}
|
||||
|
||||
var _wrap_Size unsafe.Pointer
|
||||
|
||||
func _swig_getSize() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Size, _swig_p)
|
||||
return
|
||||
}
|
||||
var Size int = _swig_getSize()
|
||||
var _wrap_chitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_chitMat_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_chitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetChitMat(arg1 Material) {
|
||||
_swig_wrap_chitMat_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_chitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_chitMat_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_chitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetChitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_chitMat_get()
|
||||
}
|
||||
|
||||
var _wrap_hitMat_val_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_val_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_val_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetHitMat_val(arg1 Material) {
|
||||
_swig_wrap_hitMat_val_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_hitMat_val_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_val_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_val_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetHitMat_val() (_swig_ret Material) {
|
||||
return _swig_wrap_hitMat_val_get()
|
||||
}
|
||||
|
||||
var _wrap_hitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetHitMat(arg1 Material) {
|
||||
_swig_wrap_hitMat_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_hitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetHitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_hitMat_get()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,621 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrays_global_twodim.i
|
||||
|
||||
package arrays_global_twodim
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const ARRAY_LEN_X int = 2
|
||||
const ARRAY_LEN_Y int = 4
|
||||
type Finger int
|
||||
var _wrap_One unsafe.Pointer
|
||||
|
||||
func _swig_getOne() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_One, _swig_p)
|
||||
return
|
||||
}
|
||||
var One int = _swig_getOne()
|
||||
var _wrap_Two unsafe.Pointer
|
||||
|
||||
func _swig_getTwo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Two, _swig_p)
|
||||
return
|
||||
}
|
||||
var Two int = _swig_getTwo()
|
||||
var _wrap_Three unsafe.Pointer
|
||||
|
||||
func _swig_getThree() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Three, _swig_p)
|
||||
return
|
||||
}
|
||||
var Three int = _swig_getThree()
|
||||
var _wrap_Four unsafe.Pointer
|
||||
|
||||
func _swig_getFour() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Four, _swig_p)
|
||||
return
|
||||
}
|
||||
var Four int = _swig_getFour()
|
||||
var _wrap_Five unsafe.Pointer
|
||||
|
||||
func _swig_getFive() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Five, _swig_p)
|
||||
return
|
||||
}
|
||||
var Five int = _swig_getFive()
|
||||
type SwigcptrSimpleStruct uintptr
|
||||
|
||||
func (p SwigcptrSimpleStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSimpleStruct) SwigIsSimpleStruct() {
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_set(base SwigcptrSimpleStruct, _ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) SetDouble_field(arg2 float64) {
|
||||
_swig_wrap_SimpleStruct_double_field_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_SimpleStruct_double_field_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SimpleStruct_double_field_get(base SwigcptrSimpleStruct) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SimpleStruct_double_field_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSimpleStruct) GetDouble_field() (_swig_ret float64) {
|
||||
return _swig_wrap_SimpleStruct_double_field_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_SimpleStruct() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSimpleStruct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_new_SimpleStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_SimpleStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_SimpleStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_SimpleStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSimpleStruct(arg1 SimpleStruct) {
|
||||
_swig_wrap_delete_SimpleStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SimpleStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSimpleStruct()
|
||||
SetDouble_field(arg2 float64)
|
||||
GetDouble_field() (_swig_ret float64)
|
||||
}
|
||||
|
||||
var _wrap_array_c_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_c_set(base *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_c_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_c(arg1 *string) {
|
||||
_swig_wrap_array_c_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_c_get unsafe.Pointer
|
||||
|
||||
func GetArray_c() (_swig_ret *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_c_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_sc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_sc_set(base *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_sc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_sc(arg1 *string) {
|
||||
_swig_wrap_array_sc_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_sc_get unsafe.Pointer
|
||||
|
||||
func GetArray_sc() (_swig_ret *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_sc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_uc_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_uc_set(base *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_uc_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_uc(arg1 *string) {
|
||||
_swig_wrap_array_uc_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_uc_get unsafe.Pointer
|
||||
|
||||
func GetArray_uc() (_swig_ret *string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_uc_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_s_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_s_set(base **int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_s_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_s(arg1 **int16) {
|
||||
_swig_wrap_array_s_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_s_get unsafe.Pointer
|
||||
|
||||
func GetArray_s() (_swig_ret **int16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_s_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_us_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_us_set(base **uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_us_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_us(arg1 **uint16) {
|
||||
_swig_wrap_array_us_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_us_get unsafe.Pointer
|
||||
|
||||
func GetArray_us() (_swig_ret **uint16) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_us_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_i_set(base **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_i(arg1 **int) {
|
||||
_swig_wrap_array_i_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_i_get unsafe.Pointer
|
||||
|
||||
func GetArray_i() (_swig_ret **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ui_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ui_set(base **uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ui_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ui(arg1 **uint) {
|
||||
_swig_wrap_array_ui_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ui_get unsafe.Pointer
|
||||
|
||||
func GetArray_ui() (_swig_ret **uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ui_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_l_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_l_set(base **int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_l_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_l(arg1 **int64) {
|
||||
_swig_wrap_array_l_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_l_get unsafe.Pointer
|
||||
|
||||
func GetArray_l() (_swig_ret **int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_l_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ul_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ul_set(base **uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ul_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ul(arg1 **uint64) {
|
||||
_swig_wrap_array_ul_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ul_get unsafe.Pointer
|
||||
|
||||
func GetArray_ul() (_swig_ret **uint64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ul_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_ll_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ll_set(base **int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ll_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ll(arg1 **int64) {
|
||||
_swig_wrap_array_ll_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ll_get unsafe.Pointer
|
||||
|
||||
func GetArray_ll() (_swig_ret **int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ll_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_f_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_f_set(base **float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_f_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_f(arg1 **float32) {
|
||||
_swig_wrap_array_f_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_f_get unsafe.Pointer
|
||||
|
||||
func GetArray_f() (_swig_ret **float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_f_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_d_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_d_set(base **float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_d_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_d(arg1 **float64) {
|
||||
_swig_wrap_array_d_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_d_get unsafe.Pointer
|
||||
|
||||
func GetArray_d() (_swig_ret **float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_d_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_struct_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_struct_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_struct_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_struct(arg1 SimpleStruct) {
|
||||
_swig_wrap_array_struct_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_array_struct_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_struct_get() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_struct_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetArray_struct() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_array_struct_get()
|
||||
}
|
||||
|
||||
var _wrap_array_structpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_structpointers_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_structpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_structpointers(arg1 SimpleStruct) {
|
||||
_swig_wrap_array_structpointers_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_array_structpointers_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_structpointers_get() (base SwigcptrSimpleStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_structpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetArray_structpointers() (_swig_ret SimpleStruct) {
|
||||
return _swig_wrap_array_structpointers_get()
|
||||
}
|
||||
|
||||
var _wrap_array_ipointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_ipointers_set(base ***int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_ipointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_ipointers(arg1 ***int) {
|
||||
_swig_wrap_array_ipointers_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_ipointers_get unsafe.Pointer
|
||||
|
||||
func GetArray_ipointers() (_swig_ret ***int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_ipointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_enum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_enum_set(base **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_enum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_enum(arg1 **Finger) {
|
||||
_swig_wrap_array_enum_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_enum_get unsafe.Pointer
|
||||
|
||||
func GetArray_enum() (_swig_ret **Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_enum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_enumpointers_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_array_enumpointers_set(base ***Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_array_enumpointers_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetArray_enumpointers(arg1 ***Finger) {
|
||||
_swig_wrap_array_enumpointers_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_array_enumpointers_get unsafe.Pointer
|
||||
|
||||
func GetArray_enumpointers() (_swig_ret ***Finger) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_enumpointers_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_array_const_i_get unsafe.Pointer
|
||||
|
||||
func GetArray_const_i() (_swig_ret **int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_array_const_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_fn_taking_arrays unsafe.Pointer
|
||||
|
||||
func _swig_wrap_fn_taking_arrays(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_fn_taking_arrays, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Fn_taking_arrays(arg1 SimpleStruct) {
|
||||
_swig_wrap_fn_taking_arrays(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_get_2d_array unsafe.Pointer
|
||||
|
||||
func Get_2d_array(arg1 **int, arg2 int, arg3 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_get_2d_array, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrMaterial uintptr
|
||||
|
||||
func (p SwigcptrMaterial) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMaterial) SwigIsMaterial() {
|
||||
}
|
||||
|
||||
var _wrap_new_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Material() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMaterial() (_swig_ret Material) {
|
||||
return _swig_wrap_new_Material()
|
||||
}
|
||||
|
||||
var _wrap_delete_Material unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Material(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Material, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMaterial(arg1 Material) {
|
||||
_swig_wrap_delete_Material(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Material interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMaterial()
|
||||
}
|
||||
|
||||
var _wrap_Size unsafe.Pointer
|
||||
|
||||
func _swig_getSize() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Size, _swig_p)
|
||||
return
|
||||
}
|
||||
var Size int = _swig_getSize()
|
||||
var _wrap_chitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_chitMat_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_chitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetChitMat(arg1 Material) {
|
||||
_swig_wrap_chitMat_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_chitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_chitMat_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_chitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetChitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_chitMat_get()
|
||||
}
|
||||
|
||||
var _wrap_hitMat_val_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_val_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_val_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetHitMat_val(arg1 Material) {
|
||||
_swig_wrap_hitMat_val_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_hitMat_val_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_val_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_val_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetHitMat_val() (_swig_ret Material) {
|
||||
return _swig_wrap_hitMat_val_get()
|
||||
}
|
||||
|
||||
var _wrap_hitMat_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetHitMat(arg1 Material) {
|
||||
_swig_wrap_hitMat_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_hitMat_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hitMat_get() (base SwigcptrMaterial) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hitMat_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetHitMat() (_swig_ret Material) {
|
||||
return _swig_wrap_hitMat_get()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,190 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../arrays_scope.i
|
||||
|
||||
package arrays_scope
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_ASIZE unsafe.Pointer
|
||||
|
||||
func _swig_getASIZE() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ASIZE, _swig_p)
|
||||
return
|
||||
}
|
||||
var ASIZE int = _swig_getASIZE()
|
||||
var _wrap_BBSIZE unsafe.Pointer
|
||||
|
||||
func _swig_getBBSIZE() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_BBSIZE, _swig_p)
|
||||
return
|
||||
}
|
||||
var BBSIZE int = _swig_getBBSIZE()
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_CCSIZE_Bar unsafe.Pointer
|
||||
|
||||
func _swig_getBar_CCSIZE_Bar() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_CCSIZE_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
var BarCCSIZE int = _swig_getBar_CCSIZE_Bar()
|
||||
var _wrap_Bar_adata_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_adata_set(base SwigcptrBar, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_adata_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetAdata(arg2 *int) {
|
||||
_swig_wrap_Bar_adata_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Bar_adata_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_adata_get(base SwigcptrBar) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_adata_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetAdata() (_swig_ret *int) {
|
||||
return _swig_wrap_Bar_adata_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_bdata_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_bdata_set(base SwigcptrBar, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_bdata_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetBdata(arg2 *int) {
|
||||
_swig_wrap_Bar_bdata_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Bar_bdata_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_bdata_get(base SwigcptrBar) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_bdata_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetBdata() (_swig_ret *int) {
|
||||
return _swig_wrap_Bar_bdata_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_cdata_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_cdata_set(base SwigcptrBar, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_cdata_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetCdata(arg2 *int) {
|
||||
_swig_wrap_Bar_cdata_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Bar_cdata_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_cdata_get(base SwigcptrBar) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_cdata_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetCdata() (_swig_ret *int) {
|
||||
return _swig_wrap_Bar_cdata_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_blah(base SwigcptrBar, _ *int, _ *int, _ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Blah(arg2 *int, arg3 *int, arg4 *int) {
|
||||
_swig_wrap_Bar_blah(arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
SetAdata(arg2 *int)
|
||||
GetAdata() (_swig_ret *int)
|
||||
SetBdata(arg2 *int)
|
||||
GetBdata() (_swig_ret *int)
|
||||
SetCdata(arg2 *int)
|
||||
GetCdata() (_swig_ret *int)
|
||||
Blah(arg2 *int, arg3 *int, arg4 *int)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,933 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../autodoc.i
|
||||
|
||||
package autodoc
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type Hola int
|
||||
var _wrap_hi unsafe.Pointer
|
||||
|
||||
func _swig_gethi() (_swig_ret Hola) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_hi, _swig_p)
|
||||
return
|
||||
}
|
||||
var Hi Hola = _swig_gethi()
|
||||
var _wrap_hello unsafe.Pointer
|
||||
|
||||
func _swig_gethello() (_swig_ret Hola) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_hello, _swig_p)
|
||||
return
|
||||
}
|
||||
var Hello Hola = _swig_gethello()
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A(base int, _ int16, _ Hola) (_ SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA(arg1 int, arg2 int16, arg3 Hola) (_swig_ret A) {
|
||||
return _swig_wrap_new_A(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_A_funk unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_funk(base SwigcptrA, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_funk, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Funk(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_funk(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_func0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func0(base SwigcptrA, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func0(arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func0(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_A_func1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func1(base SwigcptrA, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func1(arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func1(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_A_func2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func2(base SwigcptrA, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func2(arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func2(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_A_func3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func3(base SwigcptrA, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func3(arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func3(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_A_func0default__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func0default__SWIG_0(base SwigcptrA, _ uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func0default__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func0default__SWIG_0(arg2 A, arg3 int16, arg4 int, arg5 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func0default__SWIG_0(arg1, arg2.Swigcptr(), arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
var _wrap_A_func0default__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func0default__SWIG_1(base SwigcptrA, _ uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func0default__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func0default__SWIG_1(arg2 A, arg3 int16, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func0default__SWIG_1(arg1, arg2.Swigcptr(), arg3, arg4)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) Func0default(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return p.Func0default__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return p.Func0default__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func1default__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func1default__SWIG_0(base SwigcptrA, _ uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func1default__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func1default__SWIG_0(arg2 A, arg3 int16, arg4 int, arg5 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func1default__SWIG_0(arg1, arg2.Swigcptr(), arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
var _wrap_A_func1default__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func1default__SWIG_1(base SwigcptrA, _ uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func1default__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func1default__SWIG_1(arg2 A, arg3 int16, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func1default__SWIG_1(arg1, arg2.Swigcptr(), arg3, arg4)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) Func1default(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return p.Func1default__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return p.Func1default__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func2default__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func2default__SWIG_0(base SwigcptrA, _ uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func2default__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func2default__SWIG_0(arg2 A, arg3 int16, arg4 int, arg5 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func2default__SWIG_0(arg1, arg2.Swigcptr(), arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
var _wrap_A_func2default__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func2default__SWIG_1(base SwigcptrA, _ uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func2default__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func2default__SWIG_1(arg2 A, arg3 int16, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func2default__SWIG_1(arg1, arg2.Swigcptr(), arg3, arg4)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) Func2default(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return p.Func2default__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return p.Func2default__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func3default__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func3default__SWIG_0(base SwigcptrA, _ uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func3default__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func3default__SWIG_0(arg2 A, arg3 int16, arg4 int, arg5 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func3default__SWIG_0(arg1, arg2.Swigcptr(), arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
var _wrap_A_func3default__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func3default__SWIG_1(base SwigcptrA, _ uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func3default__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Func3default__SWIG_1(arg2 A, arg3 int16, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func3default__SWIG_1(arg1, arg2.Swigcptr(), arg3, arg4)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) Func3default(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return p.Func3default__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return p.Func3default__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func0static__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func0static__SWIG_0(base uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func0static__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc0static__SWIG_0(arg1 A, arg2 int16, arg3 int, arg4 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func0static__SWIG_0(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_A_func0static__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func0static__SWIG_1(base uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func0static__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc0static__SWIG_1(arg1 A, arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func0static__SWIG_1(arg1.Swigcptr(), arg2, arg3)
|
||||
}
|
||||
|
||||
func AFunc0static(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return AFunc0static__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return AFunc0static__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func1static__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func1static__SWIG_0(base uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func1static__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc1static__SWIG_0(arg1 A, arg2 int16, arg3 int, arg4 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func1static__SWIG_0(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_A_func1static__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func1static__SWIG_1(base uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func1static__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc1static__SWIG_1(arg1 A, arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func1static__SWIG_1(arg1.Swigcptr(), arg2, arg3)
|
||||
}
|
||||
|
||||
func AFunc1static(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return AFunc1static__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return AFunc1static__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func2static__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func2static__SWIG_0(base uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func2static__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc2static__SWIG_0(arg1 A, arg2 int16, arg3 int, arg4 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func2static__SWIG_0(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_A_func2static__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func2static__SWIG_1(base uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func2static__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc2static__SWIG_1(arg1 A, arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func2static__SWIG_1(arg1.Swigcptr(), arg2, arg3)
|
||||
}
|
||||
|
||||
func AFunc2static(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return AFunc2static__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return AFunc2static__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_func3static__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func3static__SWIG_0(base uintptr, _ int16, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func3static__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc3static__SWIG_0(arg1 A, arg2 int16, arg3 int, arg4 float64) (_swig_ret int) {
|
||||
return _swig_wrap_A_func3static__SWIG_0(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_A_func3static__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_func3static__SWIG_1(base uintptr, _ int16, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_func3static__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func AFunc3static__SWIG_1(arg1 A, arg2 int16, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_func3static__SWIG_1(arg1.Swigcptr(), arg2, arg3)
|
||||
}
|
||||
|
||||
func AFunc3static(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 3 {
|
||||
return AFunc3static__SWIG_1(a[0].(A), a[1].(int16), a[2].(int))
|
||||
}
|
||||
if argc == 4 {
|
||||
return AFunc3static__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_A_variable_a_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_a_set(base SwigcptrA, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_a_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) SetVariable_a(arg2 int) {
|
||||
_swig_wrap_A_variable_a_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_a_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_a_get(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_a_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) GetVariable_a() (_swig_ret int) {
|
||||
return _swig_wrap_A_variable_a_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_b_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_b_set(base SwigcptrA, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_b_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) SetVariable_b(arg2 int) {
|
||||
_swig_wrap_A_variable_b_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_b_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_b_get(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_b_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) GetVariable_b() (_swig_ret int) {
|
||||
return _swig_wrap_A_variable_b_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_c_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_c_set(base SwigcptrA, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_c_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) SetVariable_c(arg2 int) {
|
||||
_swig_wrap_A_variable_c_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_c_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_c_get(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_c_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) GetVariable_c() (_swig_ret int) {
|
||||
return _swig_wrap_A_variable_c_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_d_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_d_set(base SwigcptrA, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_d_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) SetVariable_d(arg2 int) {
|
||||
_swig_wrap_A_variable_d_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_variable_d_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_variable_d_get(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_variable_d_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) GetVariable_d() (_swig_ret int) {
|
||||
return _swig_wrap_A_variable_d_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Funk(arg2 int) (_swig_ret int)
|
||||
Func0(arg2 int16, arg3 int) (_swig_ret int)
|
||||
Func1(arg2 int16, arg3 int) (_swig_ret int)
|
||||
Func2(arg2 int16, arg3 int) (_swig_ret int)
|
||||
Func3(arg2 int16, arg3 int) (_swig_ret int)
|
||||
Func0default(a ...interface{}) int
|
||||
Func1default(a ...interface{}) int
|
||||
Func2default(a ...interface{}) int
|
||||
Func3default(a ...interface{}) int
|
||||
SetVariable_a(arg2 int)
|
||||
GetVariable_a() (_swig_ret int)
|
||||
SetVariable_b(arg2 int)
|
||||
GetVariable_b() (_swig_ret int)
|
||||
SetVariable_c(arg2 int)
|
||||
GetVariable_c() (_swig_ret int)
|
||||
SetVariable_d(arg2 int)
|
||||
GetVariable_d() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B(base int, _ int, _ Hola) (_ SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB(arg1 int, arg2 int, arg3 Hola) (_swig_ret B) {
|
||||
return _swig_wrap_new_B(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_B_funk unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_funk(base SwigcptrB, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_funk, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrB) Funk(arg2 int, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_B_funk(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
Funk(arg2 int, arg3 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_new_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_C(base int, _ int, _ Hola) (_ SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewC(arg1 int, arg2 int, arg3 Hola) (_swig_ret C) {
|
||||
return _swig_wrap_new_C(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_new_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_D(base int, _ int, _ Hola) (_ SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewD(arg1 int, arg2 int, arg3 Hola) (_swig_ret D) {
|
||||
return _swig_wrap_new_D(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
}
|
||||
|
||||
type SwigcptrE uintptr
|
||||
|
||||
func (p SwigcptrE) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsE() {
|
||||
}
|
||||
|
||||
var _wrap_new_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E(base int, _ int, _ Hola) (_ SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE(arg1 int, arg2 int, arg3 Hola) (_swig_ret E) {
|
||||
return _swig_wrap_new_E(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_delete_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_E(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteE(arg1 E) {
|
||||
_swig_wrap_delete_E(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type E interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsE()
|
||||
}
|
||||
|
||||
type SwigcptrF uintptr
|
||||
|
||||
func (p SwigcptrF) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrF) SwigIsF() {
|
||||
}
|
||||
|
||||
var _wrap_new_F unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_F(base int, _ int, _ Hola) (_ SwigcptrF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_F, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewF(arg1 int, arg2 int, arg3 Hola) (_swig_ret F) {
|
||||
return _swig_wrap_new_F(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_delete_F unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_F(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_F, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteF(arg1 F) {
|
||||
_swig_wrap_delete_F(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type F interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsF()
|
||||
}
|
||||
|
||||
var _wrap_funk unsafe.Pointer
|
||||
|
||||
func _swig_wrap_funk(base uintptr, _ int16, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_funk, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Funk(arg1 A, arg2 int16, arg3 int, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_funk(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_funkdefaults__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_funkdefaults__SWIG_0(base uintptr, _ int16, _ int, _ int, _ float64) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_funkdefaults__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Funkdefaults__SWIG_0(arg1 A, arg2 int16, arg3 int, arg4 int, arg5 float64) (_swig_ret int) {
|
||||
return _swig_wrap_funkdefaults__SWIG_0(arg1.Swigcptr(), arg2, arg3, arg4, arg5)
|
||||
}
|
||||
|
||||
var _wrap_funkdefaults__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_funkdefaults__SWIG_1(base uintptr, _ int16, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_funkdefaults__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Funkdefaults__SWIG_1(arg1 A, arg2 int16, arg3 int, arg4 int) (_swig_ret int) {
|
||||
return _swig_wrap_funkdefaults__SWIG_1(arg1.Swigcptr(), arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
func Funkdefaults(a ...interface{}) int {
|
||||
argc := len(a)
|
||||
if argc == 4 {
|
||||
return Funkdefaults__SWIG_1(a[0].(A), a[1].(int16), a[2].(int), a[3].(int))
|
||||
}
|
||||
if argc == 5 {
|
||||
return Funkdefaults__SWIG_0(a[0].(A), a[1].(int16), a[2].(int), a[3].(int), a[4].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_func_input unsafe.Pointer
|
||||
|
||||
func Func_input(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_func_input, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_func_output unsafe.Pointer
|
||||
|
||||
func Func_output(arg1 []int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_func_output, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_func_inout unsafe.Pointer
|
||||
|
||||
func Func_inout(arg1 []int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_func_inout, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_FUNC_CB_CALLBACK unsafe.Pointer
|
||||
|
||||
func _swig_getFUNC_CB_CALLBACK() (_swig_ret _swig_fnptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_FUNC_CB_CALLBACK, _swig_p)
|
||||
return
|
||||
}
|
||||
var FUNC_CB_CALLBACK _swig_fnptr = _swig_getFUNC_CB_CALLBACK()
|
||||
var _wrap_func_cb unsafe.Pointer
|
||||
|
||||
func Func_cb(arg1 int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_func_cb, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrS uintptr
|
||||
|
||||
func (p SwigcptrS) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrS) SwigIsS() {
|
||||
}
|
||||
|
||||
var _wrap_S_a_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_S_a_set(base SwigcptrS, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_S_a_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrS) SetA(arg2 int) {
|
||||
_swig_wrap_S_a_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_S_a_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_S_a_get(base SwigcptrS) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_S_a_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrS) GetA() (_swig_ret int) {
|
||||
return _swig_wrap_S_a_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_S_b_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_S_b_set(base SwigcptrS, _ byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_S_b_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrS) SetB(arg2 byte) {
|
||||
_swig_wrap_S_b_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_S_b_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_S_b_get(base SwigcptrS) (_ byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_S_b_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrS) GetB() (_swig_ret byte) {
|
||||
return _swig_wrap_S_b_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_S unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_S() (base SwigcptrS) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_S, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewS() (_swig_ret S) {
|
||||
return _swig_wrap_new_S()
|
||||
}
|
||||
|
||||
var _wrap_delete_S unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_S(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_S, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteS(arg1 S) {
|
||||
_swig_wrap_delete_S(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type S interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsS()
|
||||
SetA(arg2 int)
|
||||
GetA() (_swig_ret int)
|
||||
SetB(arg2 byte)
|
||||
GetB() (_swig_ret byte)
|
||||
}
|
||||
|
||||
var _wrap_banana unsafe.Pointer
|
||||
|
||||
func _swig_wrap_banana(base uintptr, _ uintptr, _ int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_banana, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Banana(arg1 S, arg2 S, arg3 int, arg4 int) {
|
||||
_swig_wrap_banana(arg1.Swigcptr(), arg2.Swigcptr(), arg3, arg4)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../bloody_hell.i
|
||||
|
||||
package bloody_hell
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const KMaxIOCTLSpaceParmsSize int = 128
|
||||
type SwigcptrSM_CHANNEL_IX_DUMP_PARMS uintptr
|
||||
|
||||
func (p SwigcptrSM_CHANNEL_IX_DUMP_PARMS) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSM_CHANNEL_IX_DUMP_PARMS) SwigIsSM_CHANNEL_IX_DUMP_PARMS() {
|
||||
}
|
||||
|
||||
var _wrap_SM_CHANNEL_IX_DUMP_PARMS_data_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_set(base SwigcptrSM_CHANNEL_IX_DUMP_PARMS, _ *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSM_CHANNEL_IX_DUMP_PARMS) SetData(arg2 *uint) {
|
||||
_swig_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_SM_CHANNEL_IX_DUMP_PARMS_data_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_get(base SwigcptrSM_CHANNEL_IX_DUMP_PARMS) (_ *uint) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrSM_CHANNEL_IX_DUMP_PARMS) GetData() (_swig_ret *uint) {
|
||||
return _swig_wrap_SM_CHANNEL_IX_DUMP_PARMS_data_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_SM_CHANNEL_IX_DUMP_PARMS unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_SM_CHANNEL_IX_DUMP_PARMS() (base SwigcptrSM_CHANNEL_IX_DUMP_PARMS) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_SM_CHANNEL_IX_DUMP_PARMS, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSM_CHANNEL_IX_DUMP_PARMS() (_swig_ret SM_CHANNEL_IX_DUMP_PARMS) {
|
||||
return _swig_wrap_new_SM_CHANNEL_IX_DUMP_PARMS()
|
||||
}
|
||||
|
||||
var _wrap_delete_SM_CHANNEL_IX_DUMP_PARMS unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_SM_CHANNEL_IX_DUMP_PARMS(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_SM_CHANNEL_IX_DUMP_PARMS, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSM_CHANNEL_IX_DUMP_PARMS(arg1 SM_CHANNEL_IX_DUMP_PARMS) {
|
||||
_swig_wrap_delete_SM_CHANNEL_IX_DUMP_PARMS(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SM_CHANNEL_IX_DUMP_PARMS interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSM_CHANNEL_IX_DUMP_PARMS()
|
||||
SetData(arg2 *uint)
|
||||
GetData() (_swig_ret *uint)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,101 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../bom_utf8.i
|
||||
|
||||
package bom_utf8
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrNotALotHere uintptr
|
||||
|
||||
func (p SwigcptrNotALotHere) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrNotALotHere) SwigIsNotALotHere() {
|
||||
}
|
||||
|
||||
var _wrap_NotALotHere_n_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_NotALotHere_n_set(base SwigcptrNotALotHere, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_NotALotHere_n_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrNotALotHere) SetN(arg2 int) {
|
||||
_swig_wrap_NotALotHere_n_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_NotALotHere_n_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_NotALotHere_n_get(base SwigcptrNotALotHere) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_NotALotHere_n_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrNotALotHere) GetN() (_swig_ret int) {
|
||||
return _swig_wrap_NotALotHere_n_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_NotALotHere unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_NotALotHere() (base SwigcptrNotALotHere) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_NotALotHere, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewNotALotHere() (_swig_ret NotALotHere) {
|
||||
return _swig_wrap_new_NotALotHere()
|
||||
}
|
||||
|
||||
var _wrap_delete_NotALotHere unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_NotALotHere(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_NotALotHere, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteNotALotHere(arg1 NotALotHere) {
|
||||
_swig_wrap_delete_NotALotHere(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type NotALotHere interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsNotALotHere()
|
||||
SetN(arg2 int)
|
||||
GetN() (_swig_ret int)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,370 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../bools.i
|
||||
|
||||
package bools
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const Constbool bool = false
|
||||
var _wrap_bool1_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_bool1_set(base bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_bool1_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBool1(arg1 bool) {
|
||||
_swig_wrap_bool1_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_bool1_get unsafe.Pointer
|
||||
|
||||
func GetBool1() (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_bool1_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_bool2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_bool2_set(base bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_bool2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBool2(arg1 bool) {
|
||||
_swig_wrap_bool2_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_bool2_get unsafe.Pointer
|
||||
|
||||
func GetBool2() (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_bool2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_pbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_pbool_set(base *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_pbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetPbool(arg1 *bool) {
|
||||
_swig_wrap_pbool_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_pbool_get unsafe.Pointer
|
||||
|
||||
func GetPbool() (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_pbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_rbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_rbool_set(base *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_rbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetRbool(arg1 *bool) {
|
||||
_swig_wrap_rbool_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_rbool_get unsafe.Pointer
|
||||
|
||||
func GetRbool() (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_rbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_const_pbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_const_pbool_set(base *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_const_pbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetConst_pbool(arg1 *bool) {
|
||||
_swig_wrap_const_pbool_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_const_pbool_get unsafe.Pointer
|
||||
|
||||
func GetConst_pbool() (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_const_pbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_const_rbool_get unsafe.Pointer
|
||||
|
||||
func GetConst_rbool() (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_const_rbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_eax unsafe.Pointer
|
||||
|
||||
func Eax() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_eax, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_bo unsafe.Pointer
|
||||
|
||||
func Bo(arg1 bool) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_bo, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_rbo unsafe.Pointer
|
||||
|
||||
func Rbo(arg1 *bool) (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_rbo, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_pbo unsafe.Pointer
|
||||
|
||||
func Pbo(arg1 *bool) (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_pbo, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_const_rbo unsafe.Pointer
|
||||
|
||||
func Const_rbo(arg1 bool) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_const_rbo, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_const_pbo unsafe.Pointer
|
||||
|
||||
func Const_pbo(arg1 *bool) (_swig_ret *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_const_pbo, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_value unsafe.Pointer
|
||||
|
||||
func Value(arg1 *bool) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_value, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrBoolStructure uintptr
|
||||
|
||||
func (p SwigcptrBoolStructure) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBoolStructure) SwigIsBoolStructure() {
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_bool1_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_bool1_set(base SwigcptrBoolStructure, _ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_bool1_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) SetM_bool1(arg2 bool) {
|
||||
_swig_wrap_BoolStructure_m_bool1_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_bool1_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_bool1_get(base SwigcptrBoolStructure) (_ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_bool1_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_bool1() (_swig_ret bool) {
|
||||
return _swig_wrap_BoolStructure_m_bool1_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_bool2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_bool2_set(base SwigcptrBoolStructure, _ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_bool2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) SetM_bool2(arg2 bool) {
|
||||
_swig_wrap_BoolStructure_m_bool2_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_bool2_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_bool2_get(base SwigcptrBoolStructure) (_ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_bool2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_bool2() (_swig_ret bool) {
|
||||
return _swig_wrap_BoolStructure_m_bool2_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_pbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_pbool_set(base SwigcptrBoolStructure, _ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_pbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) SetM_pbool(arg2 *bool) {
|
||||
_swig_wrap_BoolStructure_m_pbool_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_pbool_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_pbool_get(base SwigcptrBoolStructure) (_ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_pbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_pbool() (_swig_ret *bool) {
|
||||
return _swig_wrap_BoolStructure_m_pbool_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_rbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_rbool_set(base SwigcptrBoolStructure, _ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_rbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) SetM_rbool(arg2 *bool) {
|
||||
_swig_wrap_BoolStructure_m_rbool_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_rbool_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_rbool_get(base SwigcptrBoolStructure) (_ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_rbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_rbool() (_swig_ret *bool) {
|
||||
return _swig_wrap_BoolStructure_m_rbool_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_const_pbool_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_const_pbool_set(base SwigcptrBoolStructure, _ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_const_pbool_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) SetM_const_pbool(arg2 *bool) {
|
||||
_swig_wrap_BoolStructure_m_const_pbool_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_const_pbool_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_const_pbool_get(base SwigcptrBoolStructure) (_ *bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_const_pbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_const_pbool() (_swig_ret *bool) {
|
||||
return _swig_wrap_BoolStructure_m_const_pbool_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BoolStructure_m_const_rbool_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BoolStructure_m_const_rbool_get(base SwigcptrBoolStructure) (_ bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BoolStructure_m_const_rbool_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoolStructure) GetM_const_rbool() (_swig_ret bool) {
|
||||
return _swig_wrap_BoolStructure_m_const_rbool_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_BoolStructure unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_BoolStructure() (base SwigcptrBoolStructure) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_BoolStructure, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBoolStructure() (_swig_ret BoolStructure) {
|
||||
return _swig_wrap_new_BoolStructure()
|
||||
}
|
||||
|
||||
var _wrap_delete_BoolStructure unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_BoolStructure(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_BoolStructure, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBoolStructure(arg1 BoolStructure) {
|
||||
_swig_wrap_delete_BoolStructure(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type BoolStructure interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBoolStructure()
|
||||
SetM_bool1(arg2 bool)
|
||||
GetM_bool1() (_swig_ret bool)
|
||||
SetM_bool2(arg2 bool)
|
||||
GetM_bool2() (_swig_ret bool)
|
||||
SetM_pbool(arg2 *bool)
|
||||
GetM_pbool() (_swig_ret *bool)
|
||||
SetM_rbool(arg2 *bool)
|
||||
GetM_rbool() (_swig_ret *bool)
|
||||
SetM_const_pbool(arg2 *bool)
|
||||
GetM_const_pbool() (_swig_ret *bool)
|
||||
GetM_const_rbool() (_swig_ret bool)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,120 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../c_delete.i
|
||||
|
||||
package c_delete
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrDelete uintptr
|
||||
|
||||
func (p SwigcptrDelete) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelete) SwigIsDelete() {
|
||||
}
|
||||
|
||||
var _wrap_delete_delete_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_delete_set(base SwigcptrDelete, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_delete_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDelete) SetDelete(arg2 int) {
|
||||
_swig_wrap_delete_delete_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_delete_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_delete_get(base SwigcptrDelete) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_delete_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDelete) GetDelete() (_swig_ret int) {
|
||||
return _swig_wrap_delete_delete_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_DeleteGlobalVariable unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_DeleteGlobalVariable() (base SwigcptrDelete) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_DeleteGlobalVariable, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDeleteGlobalVariable() (_swig_ret Delete) {
|
||||
return _swig_wrap_new_DeleteGlobalVariable()
|
||||
}
|
||||
|
||||
var _wrap_delete_delete unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_delete(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_delete, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelete(arg1 Delete) {
|
||||
_swig_wrap_delete_delete(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delete interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelete()
|
||||
SetDelete(arg2 int)
|
||||
GetDelete() (_swig_ret int)
|
||||
}
|
||||
|
||||
var _wrap_DeleteGlobalVariable_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DeleteGlobalVariable_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DeleteGlobalVariable_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetDeleteGlobalVariable(arg1 int) {
|
||||
_swig_wrap_DeleteGlobalVariable_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_DeleteGlobalVariable_get unsafe.Pointer
|
||||
|
||||
func GetDeleteGlobalVariable() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_DeleteGlobalVariable_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../c_delete_function.i
|
||||
|
||||
package c_delete_function
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_delete unsafe.Pointer
|
||||
|
||||
func Delete(arg1 float64) (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_delete, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cast_operator.i
|
||||
|
||||
package cast_operator
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_A_tochar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_tochar(base SwigcptrA) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_tochar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Tochar() (_swig_ret string) {
|
||||
return _swig_wrap_A_tochar(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Tochar() (_swig_ret string)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,148 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../casts.i
|
||||
|
||||
package casts
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_A_hello unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_hello(base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_hello, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Hello() {
|
||||
_swig_wrap_A_hello(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Hello()
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B() (base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB() (_swig_ret B) {
|
||||
return _swig_wrap_new_B()
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_B_hello unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_hello(base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_hello, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrB) Hello() {
|
||||
_swig_wrap_B_hello(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
Hello()
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,111 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../catches.i
|
||||
|
||||
package catches
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrThreeException uintptr
|
||||
|
||||
func (p SwigcptrThreeException) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrThreeException) SwigIsThreeException() {
|
||||
}
|
||||
|
||||
var _wrap_new_ThreeException unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_ThreeException() (base SwigcptrThreeException) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_ThreeException, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewThreeException() (_swig_ret ThreeException) {
|
||||
return _swig_wrap_new_ThreeException()
|
||||
}
|
||||
|
||||
var _wrap_delete_ThreeException unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_ThreeException(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_ThreeException, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteThreeException(arg1 ThreeException) {
|
||||
_swig_wrap_delete_ThreeException(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type ThreeException interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsThreeException()
|
||||
}
|
||||
|
||||
var _wrap_test_catches unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_catches(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_catches, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_catches(arg1 int) {
|
||||
_swig_wrap_test_catches(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_exception_specification unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_exception_specification(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_exception_specification, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_exception_specification(arg1 int) {
|
||||
_swig_wrap_test_exception_specification(arg1)
|
||||
}
|
||||
|
||||
var _wrap_test_catches_all unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_catches_all(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_catches_all, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_catches_all(arg1 int) {
|
||||
_swig_wrap_test_catches_all(arg1)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,164 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../char_binary.i
|
||||
|
||||
package char_binary
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrTest uintptr
|
||||
|
||||
func (p SwigcptrTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest) SwigIsTest() {
|
||||
}
|
||||
|
||||
var _wrap_Test_strlen unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_strlen(base SwigcptrTest, _ string) (_ int64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_strlen, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Strlen(arg2 string) (_swig_ret int64) {
|
||||
return _swig_wrap_Test_strlen(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test() (base SwigcptrTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest() (_swig_ret Test) {
|
||||
return _swig_wrap_new_Test()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest(arg1 Test) {
|
||||
_swig_wrap_delete_Test(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Test interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest()
|
||||
Strlen(arg2 string) (_swig_ret int64)
|
||||
}
|
||||
|
||||
var _wrap_var_namet_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_var_namet_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_var_namet_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetVar_namet(arg1 string) {
|
||||
_swig_wrap_var_namet_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_var_namet_get unsafe.Pointer
|
||||
|
||||
func GetVar_namet() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_var_namet_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_var_pchar_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_var_pchar_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_var_pchar_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetVar_pchar(arg1 string) {
|
||||
_swig_wrap_var_pchar_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_var_pchar_get unsafe.Pointer
|
||||
|
||||
func GetVar_pchar() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_var_pchar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_pchar unsafe.Pointer
|
||||
|
||||
func New_pchar(arg1 int) (_swig_ret *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_new_pchar, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_delete_pchar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_pchar(base *byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_pchar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Delete_pchar(arg1 *byte) {
|
||||
_swig_wrap_delete_pchar(arg1)
|
||||
}
|
||||
|
||||
var _wrap_pchar_getitem unsafe.Pointer
|
||||
|
||||
func Pchar_getitem(arg1 *byte, arg2 int) (_swig_ret byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_pchar_getitem, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_pchar_setitem unsafe.Pointer
|
||||
|
||||
func _swig_wrap_pchar_setitem(base *byte, _ int, _ byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_pchar_setitem, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Pchar_setitem(arg1 *byte, arg2 int, arg3 byte) {
|
||||
_swig_wrap_pchar_setitem(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,69 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../char_constant.i
|
||||
|
||||
package char_constant
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
const CHAR_CONSTANT byte = 'x'
|
||||
const STRING_CONSTANT string = "xyzzy"
|
||||
var _wrap_ESC_CONST unsafe.Pointer
|
||||
|
||||
func _swig_getESC_CONST() (_swig_ret byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ESC_CONST, _swig_p)
|
||||
return
|
||||
}
|
||||
var ESC_CONST byte = _swig_getESC_CONST()
|
||||
var _wrap_NULL_CONST unsafe.Pointer
|
||||
|
||||
func _swig_getNULL_CONST() (_swig_ret byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_NULL_CONST, _swig_p)
|
||||
return
|
||||
}
|
||||
var NULL_CONST byte = _swig_getNULL_CONST()
|
||||
var _wrap_SPECIALCHAR unsafe.Pointer
|
||||
|
||||
func _swig_getSPECIALCHAR() (_swig_ret byte) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_SPECIALCHAR, _swig_p)
|
||||
return
|
||||
}
|
||||
var SPECIALCHAR byte = _swig_getSPECIALCHAR()
|
||||
var _wrap_ia_get unsafe.Pointer
|
||||
|
||||
func GetIa() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ia_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_ib_get unsafe.Pointer
|
||||
|
||||
func GetIb() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ib_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -1,302 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../char_strings.i
|
||||
|
||||
package char_strings
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_GetCharHeapString unsafe.Pointer
|
||||
|
||||
func GetCharHeapString() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetCharHeapString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetConstCharProgramCodeString unsafe.Pointer
|
||||
|
||||
func GetConstCharProgramCodeString() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetConstCharProgramCodeString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_DeleteCharHeapString unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DeleteCharHeapString() {
|
||||
var _swig_p uintptr
|
||||
_cgo_runtime_cgocall(_wrap_DeleteCharHeapString, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteCharHeapString() {
|
||||
_swig_wrap_DeleteCharHeapString()
|
||||
}
|
||||
|
||||
var _wrap_GetCharStaticString unsafe.Pointer
|
||||
|
||||
func GetCharStaticString() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetCharStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetCharStaticStringFixed unsafe.Pointer
|
||||
|
||||
func GetCharStaticStringFixed() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetCharStaticStringFixed, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetConstCharStaticStringFixed unsafe.Pointer
|
||||
|
||||
func GetConstCharStaticStringFixed() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetConstCharStaticStringFixed, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetCharHeapString unsafe.Pointer
|
||||
|
||||
func SetCharHeapString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetCharHeapString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetCharStaticString unsafe.Pointer
|
||||
|
||||
func SetCharStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetCharStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetCharArrayStaticString unsafe.Pointer
|
||||
|
||||
func SetCharArrayStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetCharArrayStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetConstCharHeapString unsafe.Pointer
|
||||
|
||||
func SetConstCharHeapString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetConstCharHeapString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetConstCharStaticString unsafe.Pointer
|
||||
|
||||
func SetConstCharStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetConstCharStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetConstCharArrayStaticString unsafe.Pointer
|
||||
|
||||
func SetConstCharArrayStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetConstCharArrayStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetCharConstStaticString unsafe.Pointer
|
||||
|
||||
func SetCharConstStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetCharConstStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetConstCharConstStaticString unsafe.Pointer
|
||||
|
||||
func SetConstCharConstStaticString(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetConstCharConstStaticString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CharPingPong unsafe.Pointer
|
||||
|
||||
func CharPingPong(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CharPingPong, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CharArrayPingPong unsafe.Pointer
|
||||
|
||||
func CharArrayPingPong(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CharArrayPingPong, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_CharArrayDimsPingPong unsafe.Pointer
|
||||
|
||||
func CharArrayDimsPingPong(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_CharArrayDimsPingPong, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_char_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_char_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobal_char(arg1 string) {
|
||||
_swig_wrap_global_char_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_global_char_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_char() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_char_array1_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_char_array1_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_array1_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobal_char_array1(arg1 string) {
|
||||
_swig_wrap_global_char_array1_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_global_char_array1_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_char_array1() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_array1_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_char_array2_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_global_char_array2_set(base string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_array2_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGlobal_char_array2(arg1 string) {
|
||||
_swig_wrap_global_char_array2_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_global_char_array2_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_char_array2() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_char_array2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_const_char_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_const_char() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_const_char_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_const_char_array1_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_const_char_array1() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_const_char_array1_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_global_const_char_array2_get unsafe.Pointer
|
||||
|
||||
func GetGlobal_const_char_array2() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_global_const_char_array2_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetNewCharString unsafe.Pointer
|
||||
|
||||
func GetNewCharString() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetNewCharString, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetNextFormat unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetNextFormat(base uintptr, _ string, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetNextFormat, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetNextFormat(arg1 Formatpos, arg2 string, arg3 OBFormat) (_swig_ret int) {
|
||||
return _swig_wrap_GetNextFormat(arg1.Swigcptr(), arg2, arg3.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_GetCharPointerRef unsafe.Pointer
|
||||
|
||||
func GetCharPointerRef() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetCharPointerRef, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetCharPointerRef unsafe.Pointer
|
||||
|
||||
func SetCharPointerRef(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetCharPointerRef, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_GetConstCharPointerRef unsafe.Pointer
|
||||
|
||||
func GetConstCharPointerRef() (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_GetConstCharPointerRef, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_SetConstCharPointerRef unsafe.Pointer
|
||||
|
||||
func SetConstCharPointerRef(arg1 string, arg2 uint) (_swig_ret bool) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_SetConstCharPointerRef, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrOBFormat uintptr
|
||||
type OBFormat interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrOBFormat) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrFormatpos uintptr
|
||||
type Formatpos interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrFormatpos) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../class_forward.i
|
||||
|
||||
package class_forward
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_new_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_C() (base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewC() (_swig_ret C) {
|
||||
return _swig_wrap_new_C()
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,262 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../class_ignore.i
|
||||
|
||||
package class_ignore
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_blah(base SwigcptrBar) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Blah() (_swig_ret string) {
|
||||
return _swig_wrap_Bar_blah(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
Blah() (_swig_ret string)
|
||||
}
|
||||
|
||||
type SwigcptrBoo uintptr
|
||||
|
||||
func (p SwigcptrBoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBoo) SwigIsBoo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Boo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Boo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Boo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBoo(arg1 Boo) {
|
||||
_swig_wrap_delete_Boo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Boo_away unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Boo_away(base SwigcptrBoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Boo_away, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBoo) Away() {
|
||||
_swig_wrap_Boo_away(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Boo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Boo() (base SwigcptrBoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Boo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBoo() (_swig_ret Boo) {
|
||||
return _swig_wrap_new_Boo()
|
||||
}
|
||||
|
||||
type Boo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBoo()
|
||||
Away()
|
||||
}
|
||||
|
||||
type SwigcptrFar uintptr
|
||||
|
||||
func (p SwigcptrFar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFar) SwigIsFar() {
|
||||
}
|
||||
|
||||
var _wrap_new_Far unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Far() (base SwigcptrFar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Far, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFar() (_swig_ret Far) {
|
||||
return _swig_wrap_new_Far()
|
||||
}
|
||||
|
||||
var _wrap_delete_Far unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Far(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Far, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFar(arg1 Far) {
|
||||
_swig_wrap_delete_Far(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrFar) SwigIsBoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrFar) SwigGetBoo() Boo {
|
||||
return SwigcptrBoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Far interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFar()
|
||||
SwigIsBoo()
|
||||
SwigGetBoo() Boo
|
||||
}
|
||||
|
||||
type SwigcptrHoo uintptr
|
||||
|
||||
func (p SwigcptrHoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrHoo) SwigIsHoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Hoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Hoo() (base SwigcptrHoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Hoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewHoo() (_swig_ret Hoo) {
|
||||
return _swig_wrap_new_Hoo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Hoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Hoo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Hoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteHoo(arg1 Hoo) {
|
||||
_swig_wrap_delete_Hoo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrHoo) SwigIsFar() {
|
||||
}
|
||||
|
||||
func (p SwigcptrHoo) SwigGetFar() Far {
|
||||
return SwigcptrFar(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrHoo) SwigIsBoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrHoo) SwigGetBoo() Boo {
|
||||
return SwigcptrBoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Hoo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsHoo()
|
||||
SwigIsFar()
|
||||
SwigGetFar() Far
|
||||
SwigIsBoo()
|
||||
SwigGetBoo() Boo
|
||||
}
|
||||
|
||||
var _wrap_do_blah unsafe.Pointer
|
||||
|
||||
func _swig_wrap_do_blah(base uintptr) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_do_blah, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Do_blah(arg1 Foo) (_swig_ret string) {
|
||||
return _swig_wrap_do_blah(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,218 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../class_scope_weird.i
|
||||
|
||||
package class_scope_weird
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo__SWIG_0() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo__SWIG_0() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo__SWIG_0()
|
||||
}
|
||||
|
||||
var _wrap_new_Foo__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo__SWIG_1(base int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo__SWIG_1(arg1 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
func NewFoo(a ...interface{}) Foo {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewFoo__SWIG_0()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewFoo__SWIG_1(a[0].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_Foo_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_bar(base SwigcptrFoo, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Bar(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_bar(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Bar(arg2 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrQuat uintptr
|
||||
|
||||
func (p SwigcptrQuat) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrQuat) SwigIsQuat() {
|
||||
}
|
||||
|
||||
var _wrap_new_Quat__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Quat__SWIG_0() (base SwigcptrQuat) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Quat__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewQuat__SWIG_0() (_swig_ret Quat) {
|
||||
return _swig_wrap_new_Quat__SWIG_0()
|
||||
}
|
||||
|
||||
var _wrap_new_Quat__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Quat__SWIG_1(base float32, _ float32, _ float32, _ float32) (_ SwigcptrQuat) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Quat__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewQuat__SWIG_1(arg1 float32, arg2 float32, arg3 float32, arg4 float32) (_swig_ret Quat) {
|
||||
return _swig_wrap_new_Quat__SWIG_1(arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_new_Quat__SWIG_2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Quat__SWIG_2(base uintptr, _ float32) (_ SwigcptrQuat) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Quat__SWIG_2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewQuat__SWIG_2(arg1 Tacka3, arg2 float32) (_swig_ret Quat) {
|
||||
return _swig_wrap_new_Quat__SWIG_2(arg1.Swigcptr(), arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_Quat__SWIG_3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Quat__SWIG_3(base uintptr) (_ SwigcptrQuat) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Quat__SWIG_3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewQuat__SWIG_3(arg1 Matrix4) (_swig_ret Quat) {
|
||||
return _swig_wrap_new_Quat__SWIG_3(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func NewQuat(a ...interface{}) Quat {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewQuat__SWIG_0()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewQuat__SWIG_3(a[0].(Matrix4))
|
||||
}
|
||||
if argc == 2 {
|
||||
return NewQuat__SWIG_2(a[0].(Tacka3), a[1].(float32))
|
||||
}
|
||||
if argc == 4 {
|
||||
return NewQuat__SWIG_1(a[0].(float32), a[1].(float32), a[2].(float32), a[3].(float32))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_Quat unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Quat(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Quat, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteQuat(arg1 Quat) {
|
||||
_swig_wrap_delete_Quat(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Quat interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsQuat()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrTacka3 uintptr
|
||||
type Tacka3 interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrTacka3) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrMatrix4 uintptr
|
||||
type Matrix4 interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrMatrix4) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,124 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../clientdata_prop_a.i
|
||||
|
||||
package clientdata_prop_a
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_A_fA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_fA(base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_fA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) FA() {
|
||||
_swig_wrap_A_fA(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
FA()
|
||||
}
|
||||
|
||||
var _wrap_test_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_A(arg1 A) {
|
||||
_swig_wrap_test_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_tA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_tA(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_tA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_tA(arg1 A) {
|
||||
_swig_wrap_test_tA(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_tA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_tA() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_tA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func New_tA() (_swig_ret A) {
|
||||
return _swig_wrap_new_tA()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,389 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../clientdata_prop_b.i
|
||||
|
||||
package clientdata_prop_b
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
import "clientdata_prop_a"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_B_fB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_fB(base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_fB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrB) FB() {
|
||||
_swig_wrap_B_fB(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B() (base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB() (_swig_ret B) {
|
||||
return _swig_wrap_new_B()
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_B_fA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_fA(base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_fA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrB) FA() {
|
||||
_swig_wrap_B_fA(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigGetA() clientdata_prop_a.A {
|
||||
return clientdata_prop_a.SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
FB()
|
||||
FA()
|
||||
SwigIsA()
|
||||
SwigGetA() clientdata_prop_a.A
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_C_fC unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_fC(base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_fC, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrC) FC() {
|
||||
_swig_wrap_C_fC(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_C() (base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewC() (_swig_ret C) {
|
||||
return _swig_wrap_new_C()
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_C_fA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_fA(base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_fA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrC) FA() {
|
||||
_swig_wrap_C_fA(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() clientdata_prop_a.A {
|
||||
return clientdata_prop_a.SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
FC()
|
||||
FA()
|
||||
SwigIsA()
|
||||
SwigGetA() clientdata_prop_a.A
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_D_fD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_fD(base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_fD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrD) FD() {
|
||||
_swig_wrap_D_fD(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_D() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewD() (_swig_ret D) {
|
||||
return _swig_wrap_new_D()
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_D_fA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_fA(base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_fA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrD) FA() {
|
||||
_swig_wrap_D_fA(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetA() clientdata_prop_a.A {
|
||||
return clientdata_prop_a.SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
FD()
|
||||
FA()
|
||||
SwigIsA()
|
||||
SwigGetA() clientdata_prop_a.A
|
||||
}
|
||||
|
||||
var _wrap_test_t2A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_t2A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_t2A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_t2A(arg1 clientdata_prop_a.A) {
|
||||
_swig_wrap_test_t2A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_t3A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_t3A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_t3A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_t3A(arg1 clientdata_prop_a.A) {
|
||||
_swig_wrap_test_t3A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_B(arg1 B) {
|
||||
_swig_wrap_test_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_C(arg1 C) {
|
||||
_swig_wrap_test_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_D(arg1 D) {
|
||||
_swig_wrap_test_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_tD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_tD(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_tD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_tD(arg1 D) {
|
||||
_swig_wrap_test_tD(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_test_t2D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_t2D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_t2D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_t2D(arg1 D) {
|
||||
_swig_wrap_test_t2D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_t2A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_t2A() (base clientdata_prop_a.SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_t2A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func New_t2A() (_swig_ret clientdata_prop_a.A) {
|
||||
return _swig_wrap_new_t2A()
|
||||
}
|
||||
|
||||
var _wrap_new_t3A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_t3A() (base clientdata_prop_a.SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_t3A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func New_t3A() (_swig_ret clientdata_prop_a.A) {
|
||||
return _swig_wrap_new_t3A()
|
||||
}
|
||||
|
||||
var _wrap_new_tD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_tD() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_tD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func New_tD() (_swig_ret D) {
|
||||
return _swig_wrap_new_tD()
|
||||
}
|
||||
|
||||
var _wrap_new_t2D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_t2D() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_t2D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func New_t2D() (_swig_ret D) {
|
||||
return _swig_wrap_new_t2D()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,226 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../compactdefaultargs.i
|
||||
|
||||
package compactdefaultargs
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrDefaults1 uintptr
|
||||
|
||||
func (p SwigcptrDefaults1) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDefaults1) SwigIsDefaults1() {
|
||||
}
|
||||
|
||||
var _wrap_Defaults1_PUBLIC_DEFAULT_get unsafe.Pointer
|
||||
|
||||
func GetDefaults1PUBLIC_DEFAULT() (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Defaults1_PUBLIC_DEFAULT_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_Defaults1__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Defaults1__SWIG_0(base int) (_ SwigcptrDefaults1) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Defaults1__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDefaults1__SWIG_0(arg1 int) (_swig_ret Defaults1) {
|
||||
return _swig_wrap_new_Defaults1__SWIG_0(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Defaults1__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Defaults1__SWIG_1() (base SwigcptrDefaults1) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Defaults1__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDefaults1__SWIG_1() (_swig_ret Defaults1) {
|
||||
return _swig_wrap_new_Defaults1__SWIG_1()
|
||||
}
|
||||
|
||||
func NewDefaults1(a ...interface{}) Defaults1 {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewDefaults1__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewDefaults1__SWIG_0(a[0].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_Defaults1_ret__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Defaults1_ret__SWIG_0(base SwigcptrDefaults1, _ float64) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Defaults1_ret__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDefaults1) Ret__SWIG_0(arg2 float64) (_swig_ret float64) {
|
||||
return _swig_wrap_Defaults1_ret__SWIG_0(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Defaults1_ret__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Defaults1_ret__SWIG_1(base SwigcptrDefaults1) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Defaults1_ret__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDefaults1) Ret__SWIG_1() (_swig_ret float64) {
|
||||
return _swig_wrap_Defaults1_ret__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
func (p SwigcptrDefaults1) Ret(a ...interface{}) float64 {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return p.Ret__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return p.Ret__SWIG_0(a[0].(float64))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_Defaults1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Defaults1(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Defaults1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDefaults1(arg1 Defaults1) {
|
||||
_swig_wrap_delete_Defaults1(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Defaults1 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDefaults1()
|
||||
Ret(a ...interface{}) float64
|
||||
}
|
||||
|
||||
type SwigcptrDefaults2 uintptr
|
||||
|
||||
func (p SwigcptrDefaults2) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDefaults2) SwigIsDefaults2() {
|
||||
}
|
||||
|
||||
var _wrap_Defaults2_PUBLIC_DEFAULT_get unsafe.Pointer
|
||||
|
||||
func GetDefaults2PUBLIC_DEFAULT() (_swig_ret float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Defaults2_PUBLIC_DEFAULT_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_Defaults2__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Defaults2__SWIG_0(base int) (_ SwigcptrDefaults2) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Defaults2__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDefaults2__SWIG_0(arg1 int) (_swig_ret Defaults2) {
|
||||
return _swig_wrap_new_Defaults2__SWIG_0(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Defaults2__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Defaults2__SWIG_1() (base SwigcptrDefaults2) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Defaults2__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDefaults2__SWIG_1() (_swig_ret Defaults2) {
|
||||
return _swig_wrap_new_Defaults2__SWIG_1()
|
||||
}
|
||||
|
||||
func NewDefaults2(a ...interface{}) Defaults2 {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewDefaults2__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewDefaults2__SWIG_0(a[0].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_Defaults2_ret unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Defaults2_ret(base int, _ SwigcptrDefaults2, _ float64) (_ float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Defaults2_ret, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDefaults2) Ret(_swig_args ...interface{}) (_swig_ret float64) {
|
||||
var arg2 float64
|
||||
if len(_swig_args) > 0 {
|
||||
arg2 = _swig_args[0].(float64)
|
||||
}
|
||||
return _swig_wrap_Defaults2_ret(len(_swig_args), arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_Defaults2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Defaults2(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Defaults2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDefaults2(arg1 Defaults2) {
|
||||
_swig_wrap_delete_Defaults2(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Defaults2 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDefaults2()
|
||||
Ret(_swig_args ...interface{}) (_swig_ret float64)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,49 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../const_const.i
|
||||
|
||||
package const_const
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_foo(base *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Foo(arg1 *int) {
|
||||
_swig_wrap_foo(arg1)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../const_const_2.i
|
||||
|
||||
package const_const_2
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrSpam uintptr
|
||||
|
||||
func (p SwigcptrSpam) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSpam) SwigIsSpam() {
|
||||
}
|
||||
|
||||
var _wrap_new_Spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Spam() (base SwigcptrSpam) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSpam() (_swig_ret Spam) {
|
||||
return _swig_wrap_new_Spam()
|
||||
}
|
||||
|
||||
var _wrap_delete_Spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Spam(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSpam(arg1 Spam) {
|
||||
_swig_wrap_delete_Spam(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Spam interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSpam()
|
||||
}
|
||||
|
||||
type SwigcptrEggs uintptr
|
||||
|
||||
func (p SwigcptrEggs) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrEggs) SwigIsEggs() {
|
||||
}
|
||||
|
||||
var _wrap_new_Eggs unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Eggs() (base SwigcptrEggs) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Eggs, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewEggs() (_swig_ret Eggs) {
|
||||
return _swig_wrap_new_Eggs()
|
||||
}
|
||||
|
||||
var _wrap_Eggs_spam unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Eggs_spam(base SwigcptrEggs) (_ SwigcptrSpam) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Eggs_spam, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrEggs) Spam() (_swig_ret Spam) {
|
||||
return _swig_wrap_Eggs_spam(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Eggs unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Eggs(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Eggs, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteEggs(arg1 Eggs) {
|
||||
_swig_wrap_delete_Eggs(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Eggs interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsEggs()
|
||||
Spam() (_swig_ret Spam)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,71 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constant_expr.i
|
||||
|
||||
package constant_expr
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_X_get unsafe.Pointer
|
||||
|
||||
func GetX() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_X_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_FOO unsafe.Pointer
|
||||
|
||||
func _swig_getFOO() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_FOO, _swig_p)
|
||||
return
|
||||
}
|
||||
var FOO int = _swig_getFOO()
|
||||
var _wrap_d_array_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_d_array_set(base *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_d_array_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetD_array(arg1 *float64) {
|
||||
_swig_wrap_d_array_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_d_array_get unsafe.Pointer
|
||||
|
||||
func GetD_array() (_swig_ret *float64) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_d_array_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,141 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constover.i
|
||||
|
||||
package constover
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_test unsafe.Pointer
|
||||
|
||||
func Test(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_pconst unsafe.Pointer
|
||||
|
||||
func Test_pconst(arg1 string) (_swig_ret string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_pconst, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_Foo_test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test(base SwigcptrFoo, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_Foo_test(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_pconst unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_pconst(base SwigcptrFoo, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_pconst, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_pconst(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_Foo_test_pconst(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_constm unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_constm(base SwigcptrFoo, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_constm, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_constm(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_Foo_test_constm(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_pconstm unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_pconstm(base SwigcptrFoo, _ string) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_pconstm, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_pconstm(arg2 string) (_swig_ret string) {
|
||||
return _swig_wrap_Foo_test_pconstm(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Test(arg2 string) (_swig_ret string)
|
||||
Test_pconst(arg2 string) (_swig_ret string)
|
||||
Test_constm(arg2 string) (_swig_ret string)
|
||||
Test_pconstm(arg2 string) (_swig_ret string)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load diff
Binary file not shown.
|
|
@ -1,151 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constructor_exception.i
|
||||
|
||||
package constructor_exception
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrError uintptr
|
||||
|
||||
func (p SwigcptrError) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrError) SwigIsError() {
|
||||
}
|
||||
|
||||
var _wrap_new_Error unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Error() (base SwigcptrError) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Error, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewError() (_swig_ret Error) {
|
||||
return _swig_wrap_new_Error()
|
||||
}
|
||||
|
||||
var _wrap_delete_Error unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Error(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Error, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteError(arg1 Error) {
|
||||
_swig_wrap_delete_Error(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Error interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsError()
|
||||
}
|
||||
|
||||
type SwigcptrSomeClass uintptr
|
||||
|
||||
func (p SwigcptrSomeClass) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrSomeClass) SwigIsSomeClass() {
|
||||
}
|
||||
|
||||
var _wrap_new_SomeClass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_SomeClass(base int) (_ SwigcptrSomeClass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_SomeClass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewSomeClass(arg1 int) (_swig_ret SomeClass) {
|
||||
return _swig_wrap_new_SomeClass(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_SomeClass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_SomeClass(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_SomeClass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteSomeClass(arg1 SomeClass) {
|
||||
_swig_wrap_delete_SomeClass(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SomeClass interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsSomeClass()
|
||||
}
|
||||
|
||||
type SwigcptrTest uintptr
|
||||
|
||||
func (p SwigcptrTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest) SwigIsTest() {
|
||||
}
|
||||
|
||||
var _wrap_new_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test(base int) (_ SwigcptrTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest(arg1 int) (_swig_ret Test) {
|
||||
return _swig_wrap_new_Test(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest(arg1 Test) {
|
||||
_swig_wrap_delete_Test(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Test interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constructor_explicit.i
|
||||
|
||||
package constructor_explicit
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo__SWIG_0() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo__SWIG_0() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo__SWIG_0()
|
||||
}
|
||||
|
||||
var _wrap_new_Foo__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo__SWIG_1(base int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo__SWIG_1(arg1 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
func NewFoo(a ...interface{}) Foo {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewFoo__SWIG_0()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewFoo__SWIG_1(a[0].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
var _wrap_test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test(base uintptr) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test(arg1 Foo) (_swig_ret Foo) {
|
||||
return _swig_wrap_test(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,205 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constructor_ignore.i
|
||||
|
||||
package constructor_ignore
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrDelta1 uintptr
|
||||
|
||||
func (p SwigcptrDelta1) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta1) SwigIsDelta1() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta1(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta1(arg1 Delta1) {
|
||||
_swig_wrap_delete_Delta1(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta1 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta1()
|
||||
}
|
||||
|
||||
type SwigcptrDelta2 uintptr
|
||||
|
||||
func (p SwigcptrDelta2) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta2) SwigIsDelta2() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta2(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta2(arg1 Delta2) {
|
||||
_swig_wrap_delete_Delta2(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta2 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta2()
|
||||
}
|
||||
|
||||
type SwigcptrDelta3 uintptr
|
||||
|
||||
func (p SwigcptrDelta3) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta3) SwigIsDelta3() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta3(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta3(arg1 Delta3) {
|
||||
_swig_wrap_delete_Delta3(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta3 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta3()
|
||||
}
|
||||
|
||||
type SwigcptrDelta4 uintptr
|
||||
|
||||
func (p SwigcptrDelta4) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta4) SwigIsDelta4() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta4(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta4(arg1 Delta4) {
|
||||
_swig_wrap_delete_Delta4(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta4 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta4()
|
||||
}
|
||||
|
||||
type SwigcptrDelta5 uintptr
|
||||
|
||||
func (p SwigcptrDelta5) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta5) SwigIsDelta5() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta5(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta5(arg1 Delta5) {
|
||||
_swig_wrap_delete_Delta5(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta5 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta5()
|
||||
}
|
||||
|
||||
type SwigcptrDelta6 uintptr
|
||||
|
||||
func (p SwigcptrDelta6) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDelta6) SwigIsDelta6() {
|
||||
}
|
||||
|
||||
var _wrap_new_Delta6 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Delta6() (base SwigcptrDelta6) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Delta6, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDelta6() (_swig_ret Delta6) {
|
||||
return _swig_wrap_new_Delta6()
|
||||
}
|
||||
|
||||
var _wrap_delete_Delta6 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Delta6(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Delta6, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDelta6(arg1 Delta6) {
|
||||
_swig_wrap_delete_Delta6(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Delta6 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDelta6()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constructor_rename.i
|
||||
|
||||
package constructor_rename
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_RenamedConstructor unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_RenamedConstructor() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_RenamedConstructor, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewRenamedConstructor() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_RenamedConstructor()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,113 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../constructor_value.i
|
||||
|
||||
package constructor_value
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo(base int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo(arg1 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar(base uintptr) (_ SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar(arg1 Foo) (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,625 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../contract.i
|
||||
|
||||
package contract
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_test_preassert unsafe.Pointer
|
||||
|
||||
func Test_preassert(arg1 int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_preassert, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_postassert unsafe.Pointer
|
||||
|
||||
func Test_postassert(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_postassert, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_prepost unsafe.Pointer
|
||||
|
||||
func Test_prepost(arg1 int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_test_prepost, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_preassert unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_preassert(base SwigcptrFoo, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_preassert, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_preassert(arg2 int, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_test_preassert(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_postassert unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_postassert(base SwigcptrFoo, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_postassert, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_postassert(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_test_postassert(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_test_prepost unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_test_prepost(base SwigcptrFoo, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_test_prepost, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Test_prepost(arg2 int, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_test_prepost(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_Foo_stest_prepost unsafe.Pointer
|
||||
|
||||
func FooStest_prepost(arg1 int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_stest_prepost, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Test_preassert(arg2 int, arg3 int) (_swig_ret int)
|
||||
Test_postassert(arg2 int) (_swig_ret int)
|
||||
Test_prepost(arg2 int, arg3 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_test_prepost unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_test_prepost(base SwigcptrBar, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_test_prepost, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Test_prepost(arg2 int, arg3 int) (_swig_ret int) {
|
||||
return _swig_wrap_Bar_test_prepost(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_test_preassert unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_test_preassert(base SwigcptrBar, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_test_preassert, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrBar) Test_preassert(arg1 int, arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_Bar_test_preassert(_swig_base, arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Bar_test_postassert unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_test_postassert(base SwigcptrBar, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_test_postassert, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrBar) Test_postassert(arg1 int) (_swig_ret int) {
|
||||
return _swig_wrap_Bar_test_postassert(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_stest_prepost unsafe.Pointer
|
||||
|
||||
func BarStest_prepost(arg1 int, arg2 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_stest_prepost, _swig_p)
|
||||
return
|
||||
}
|
||||
func (p SwigcptrBar) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
Test_prepost(arg2 int, arg3 int) (_swig_ret int)
|
||||
Test_preassert(arg1 int, arg2 int) (_swig_ret int)
|
||||
Test_postassert(arg1 int) (_swig_ret int)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_A_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_foo(base SwigcptrA, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_A_foo(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_B_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_B_bar(base SwigcptrB, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_B_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrB) Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_B_bar(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B() (base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB() (_swig_ret B) {
|
||||
return _swig_wrap_new_B()
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_C_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_foo(base SwigcptrC, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrC) Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_C_foo(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_C_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_bar(base SwigcptrC, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrC) Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_C_bar(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_new_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_C() (base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewC() (_swig_ret C) {
|
||||
return _swig_wrap_new_C()
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_C_SwigGetB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_C_SwigGetB(base SwigcptrC) (_ SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_C_SwigGetB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrC) SwigGetB() (_swig_ret B) {
|
||||
return _swig_wrap_C_SwigGetB(arg1)
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
SwigGetB() (_swig_ret B)
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_D_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_foo(base SwigcptrD, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrD) Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_D_foo(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_D_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_bar(base SwigcptrD, _ int, _ int, _ int, _ int, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrD) Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int) {
|
||||
return _swig_wrap_D_bar(arg1, arg2, arg3, arg4, arg5, arg6)
|
||||
}
|
||||
|
||||
var _wrap_new_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_D() (base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewD() (_swig_ret D) {
|
||||
return _swig_wrap_new_D()
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsC() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetC() C {
|
||||
return SwigcptrC(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigGetB() B {
|
||||
return p.SwigGetC().SwigGetB()
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
Foo(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
Bar(arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) (_swig_ret int)
|
||||
SwigIsC()
|
||||
SwigGetC() C
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
SwigGetB() B
|
||||
}
|
||||
|
||||
type SwigcptrE uintptr
|
||||
|
||||
func (p SwigcptrE) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsE() {
|
||||
}
|
||||
|
||||
var _wrap_E_m_i_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_E_m_i_set(base SwigcptrE, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_E_m_i_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrE) SetM_i(arg2 int) {
|
||||
_swig_wrap_E_m_i_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_E_m_i_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_E_m_i_get(base SwigcptrE) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_E_m_i_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrE) GetM_i() (_swig_ret int) {
|
||||
return _swig_wrap_E_m_i_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_E_manipulate_i unsafe.Pointer
|
||||
|
||||
func _swig_wrap_E_manipulate_i(base SwigcptrE, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_E_manipulate_i, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrE) Manipulate_i(arg2 int) {
|
||||
_swig_wrap_E_manipulate_i(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E() (base SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE() (_swig_ret E) {
|
||||
return _swig_wrap_new_E()
|
||||
}
|
||||
|
||||
var _wrap_delete_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_E(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteE(arg1 E) {
|
||||
_swig_wrap_delete_E(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type E interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsE()
|
||||
SetM_i(arg2 int)
|
||||
GetM_i() (_swig_ret int)
|
||||
Manipulate_i(arg2 int)
|
||||
}
|
||||
|
||||
type SwigcptrMyClass uintptr
|
||||
|
||||
func (p SwigcptrMyClass) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrMyClass) SwigIsMyClass() {
|
||||
}
|
||||
|
||||
var _wrap_new_myClass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_myClass(base int) (_ SwigcptrMyClass) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_myClass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewMyClass(arg1 int) (_swig_ret MyClass) {
|
||||
return _swig_wrap_new_myClass(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_myClass unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_myClass(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_myClass, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteMyClass(arg1 MyClass) {
|
||||
_swig_wrap_delete_myClass(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type MyClass interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsMyClass()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,126 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../conversion.i
|
||||
|
||||
package conversion
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_toFoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_toFoo(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_toFoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) ToFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_toFoo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
ToFoo() (_swig_ret Foo)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,126 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../conversion_namespace.i
|
||||
|
||||
package conversion_namespace
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_toFoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_toFoo(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_toFoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) ToFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_toFoo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
ToFoo() (_swig_ret Foo)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,194 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../conversion_ns_template.i
|
||||
|
||||
package conversion_ns_template
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type OssTest int
|
||||
var _wrap_One unsafe.Pointer
|
||||
|
||||
func _swig_getOne() (_swig_ret OssTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_One, _swig_p)
|
||||
return
|
||||
}
|
||||
var One OssTest = _swig_getOne()
|
||||
var _wrap_Two unsafe.Pointer
|
||||
|
||||
func _swig_getTwo() (_swig_ret OssTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Two, _swig_p)
|
||||
return
|
||||
}
|
||||
var Two OssTest = _swig_getTwo()
|
||||
type SwigcptrHi uintptr
|
||||
|
||||
func (p SwigcptrHi) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrHi) SwigIsHi() {
|
||||
}
|
||||
|
||||
var _wrap_new_create unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_create(base int) (_ SwigcptrHi) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_create, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewCreate(arg1 int) (_swig_ret Hi) {
|
||||
return _swig_wrap_new_create(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Hi unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Hi(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Hi, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteHi(arg1 Hi) {
|
||||
_swig_wrap_delete_Hi(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Hi interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsHi()
|
||||
}
|
||||
|
||||
type SwigcptrFoo_One uintptr
|
||||
|
||||
func (p SwigcptrFoo_One) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo_One) SwigIsFoo_One() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo_One unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo_One() (base SwigcptrFoo_One) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo_One, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo_One() (_swig_ret Foo_One) {
|
||||
return _swig_wrap_new_Foo_One()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo_One unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo_One(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo_One, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo_One(arg1 Foo_One) {
|
||||
_swig_wrap_delete_Foo_One(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo_One interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo_One()
|
||||
}
|
||||
|
||||
type SwigcptrBar_One uintptr
|
||||
|
||||
func (p SwigcptrBar_One) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar_One) SwigIsBar_One() {
|
||||
}
|
||||
|
||||
var _wrap_new_Bar_create unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar_create(base int) (_ SwigcptrBar_One) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar_create, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar_create(arg1 int) (_swig_ret Bar_One) {
|
||||
return _swig_wrap_new_Bar_create(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_One_hello1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_One_hello1(base SwigcptrBar_One) (_ *int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_One_hello1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar_One) Hello1() (_swig_ret *int) {
|
||||
return _swig_wrap_Bar_One_hello1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_One_hello2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_One_hello2(base SwigcptrBar_One) (_ SwigcptrFoo_One) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_One_hello2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar_One) Hello2() (_swig_ret Foo_One) {
|
||||
return _swig_wrap_Bar_One_hello2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar_One unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar_One(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar_One, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar_One(arg1 Bar_One) {
|
||||
_swig_wrap_delete_Bar_One(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar_One interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar_One()
|
||||
Hello1() (_swig_ret *int)
|
||||
Hello2() (_swig_ret Foo_One)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cplusplus_throw.i
|
||||
|
||||
package cplusplus_throw
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_baz unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_baz(base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_baz, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Baz() {
|
||||
_swig_wrap_Bar_baz(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_foo(base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Foo() {
|
||||
_swig_wrap_Bar_foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_bazfoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_bazfoo(base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_bazfoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Bazfoo() {
|
||||
_swig_wrap_Bar_bazfoo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
Baz()
|
||||
Foo()
|
||||
Bazfoo()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,804 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_basic.i
|
||||
|
||||
package cpp_basic
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo(base int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo(arg1 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_num_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_num_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_num_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetNum(arg2 int) {
|
||||
_swig_wrap_Foo_num_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_num_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_num_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_num_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetNum() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_num_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_func1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_func1(base SwigcptrFoo, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_func1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Func1(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_func1(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_func2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_func2(base SwigcptrFoo, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_func2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Func2(arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_func2(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_func_ptr_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_func_ptr_set(base SwigcptrFoo, _ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_func_ptr_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetFunc_ptr(arg2 _swig_memberptr) {
|
||||
_swig_wrap_Foo_func_ptr_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_func_ptr_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_func_ptr_get(base SwigcptrFoo) (_ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_func_ptr_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetFunc_ptr() (_swig_ret _swig_memberptr) {
|
||||
return _swig_wrap_Foo_func_ptr_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo___str__ unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo___str__(base SwigcptrFoo) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo___str__, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) X__str__() (_swig_ret string) {
|
||||
return _swig_wrap_Foo___str__(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetNum(arg2 int)
|
||||
GetNum() (_swig_ret int)
|
||||
Func1(arg2 int) (_swig_ret int)
|
||||
Func2(arg2 int) (_swig_ret int)
|
||||
SetFunc_ptr(arg2 _swig_memberptr)
|
||||
GetFunc_ptr() (_swig_ret _swig_memberptr)
|
||||
X__str__() (_swig_ret string)
|
||||
}
|
||||
|
||||
type SwigcptrFooSub uintptr
|
||||
|
||||
func (p SwigcptrFooSub) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSub) SwigIsFooSub() {
|
||||
}
|
||||
|
||||
var _wrap_new_FooSub unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_FooSub() (base SwigcptrFooSub) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_FooSub, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFooSub() (_swig_ret FooSub) {
|
||||
return _swig_wrap_new_FooSub()
|
||||
}
|
||||
|
||||
var _wrap_delete_FooSub unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_FooSub(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_FooSub, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFooSub(arg1 FooSub) {
|
||||
_swig_wrap_delete_FooSub(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_SetFooSub_Num unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SetFooSub_Num(base SwigcptrFooSub, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SetFooSub_Num, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) SetNum(arg1 int) {
|
||||
_swig_wrap_SetFooSub_Num(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_GetFooSub_Num unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetFooSub_Num(base SwigcptrFooSub) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetFooSub_Num, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) GetNum() (_swig_ret int) {
|
||||
return _swig_wrap_GetFooSub_Num(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_FooSub_func1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSub_func1(base SwigcptrFooSub, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSub_func1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) Func1(arg1 int) (_swig_ret int) {
|
||||
return _swig_wrap_FooSub_func1(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_FooSub_func2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSub_func2(base SwigcptrFooSub, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSub_func2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) Func2(arg1 int) (_swig_ret int) {
|
||||
return _swig_wrap_FooSub_func2(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_SetFooSub_Func_ptr unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SetFooSub_Func_ptr(base SwigcptrFooSub, _ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SetFooSub_Func_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) SetFunc_ptr(arg1 _swig_memberptr) {
|
||||
_swig_wrap_SetFooSub_Func_ptr(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_GetFooSub_Func_ptr unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetFooSub_Func_ptr(base SwigcptrFooSub) (_ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetFooSub_Func_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) GetFunc_ptr() (_swig_ret _swig_memberptr) {
|
||||
return _swig_wrap_GetFooSub_Func_ptr(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_FooSub___str__ unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSub___str__(base SwigcptrFooSub) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSub___str__, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSub) X__str__() (_swig_ret string) {
|
||||
return _swig_wrap_FooSub___str__(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSub) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSub) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type FooSub interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFooSub()
|
||||
SetNum(arg1 int)
|
||||
GetNum() (_swig_ret int)
|
||||
Func1(arg1 int) (_swig_ret int)
|
||||
Func2(arg1 int) (_swig_ret int)
|
||||
SetFunc_ptr(arg1 _swig_memberptr)
|
||||
GetFunc_ptr() (_swig_ret _swig_memberptr)
|
||||
X__str__() (_swig_ret string)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
type SwigcptrFooSubSub uintptr
|
||||
|
||||
func (p SwigcptrFooSubSub) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSubSub) SwigIsFooSubSub() {
|
||||
}
|
||||
|
||||
var _wrap_new_FooSubSub unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_FooSubSub() (base SwigcptrFooSubSub) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_FooSubSub, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFooSubSub() (_swig_ret FooSubSub) {
|
||||
return _swig_wrap_new_FooSubSub()
|
||||
}
|
||||
|
||||
var _wrap_FooSubSub___str__ unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSubSub___str__(base SwigcptrFooSubSub) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSubSub___str__, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFooSubSub) X__str__() (_swig_ret string) {
|
||||
return _swig_wrap_FooSubSub___str__(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_FooSubSub unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_FooSubSub(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_FooSubSub, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFooSubSub(arg1 FooSubSub) {
|
||||
_swig_wrap_delete_FooSubSub(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_SetFooSubSub_Num unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SetFooSubSub_Num(base SwigcptrFooSubSub, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SetFooSubSub_Num, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) SetNum(arg1 int) {
|
||||
_swig_wrap_SetFooSubSub_Num(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_GetFooSubSub_Num unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetFooSubSub_Num(base SwigcptrFooSubSub) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetFooSubSub_Num, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) GetNum() (_swig_ret int) {
|
||||
return _swig_wrap_GetFooSubSub_Num(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_FooSubSub_func1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSubSub_func1(base SwigcptrFooSubSub, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSubSub_func1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) Func1(arg1 int) (_swig_ret int) {
|
||||
return _swig_wrap_FooSubSub_func1(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_FooSubSub_func2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FooSubSub_func2(base SwigcptrFooSubSub, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FooSubSub_func2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) Func2(arg1 int) (_swig_ret int) {
|
||||
return _swig_wrap_FooSubSub_func2(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_SetFooSubSub_Func_ptr unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SetFooSubSub_Func_ptr(base SwigcptrFooSubSub, _ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SetFooSubSub_Func_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) SetFunc_ptr(arg1 _swig_memberptr) {
|
||||
_swig_wrap_SetFooSubSub_Func_ptr(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_GetFooSubSub_Func_ptr unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetFooSubSub_Func_ptr(base SwigcptrFooSubSub) (_ _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetFooSubSub_Func_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFooSubSub) GetFunc_ptr() (_swig_ret _swig_memberptr) {
|
||||
return _swig_wrap_GetFooSubSub_Func_ptr(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSubSub) SwigIsFooSub() {
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSubSub) SwigGetFooSub() FooSub {
|
||||
return SwigcptrFooSub(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSubSub) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrFooSubSub) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type FooSubSub interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFooSubSub()
|
||||
X__str__() (_swig_ret string)
|
||||
SetNum(arg1 int)
|
||||
GetNum() (_swig_ret int)
|
||||
Func1(arg1 int) (_swig_ret int)
|
||||
Func2(arg1 int) (_swig_ret int)
|
||||
SetFunc_ptr(arg1 _swig_memberptr)
|
||||
GetFunc_ptr() (_swig_ret _swig_memberptr)
|
||||
SwigIsFooSub()
|
||||
SwigGetFooSub() FooSub
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_Bar_fptr_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fptr_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fptr_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetFptr(arg2 Foo) {
|
||||
_swig_wrap_Bar_fptr_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_fptr_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fptr_get(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fptr_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetFptr() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_fptr_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_fref_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fref_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fref_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetFref(arg2 Foo) {
|
||||
_swig_wrap_Bar_fref_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_fref_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fref_get(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fref_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetFref() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_fref_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_fval_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fval_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fval_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetFval(arg2 Foo) {
|
||||
_swig_wrap_Bar_fval_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_fval_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_fval_get(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_fval_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetFval() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_fval_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_cint_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_cint_get(base SwigcptrBar) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_cint_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetCint() (_swig_ret int) {
|
||||
return _swig_wrap_Bar_cint_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_cint_Bar unsafe.Pointer
|
||||
|
||||
func _swig_getBar_Bar_global_cint_Bar() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_cint_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
var BarGlobal_cint int = _swig_getBar_Bar_global_cint_Bar()
|
||||
var _wrap_Bar_global_fptr_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fptr_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fptr_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBarGlobal_fptr(arg1 Foo) {
|
||||
_swig_wrap_Bar_global_fptr_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_fptr_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fptr_get() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fptr_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetBarGlobal_fptr() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_global_fptr_get()
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_fref_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fref_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fref_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBarGlobal_fref(arg1 Foo) {
|
||||
_swig_wrap_Bar_global_fref_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_fref_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fref_get() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fref_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetBarGlobal_fref() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_global_fref_get()
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_fval_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fval_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fval_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetBarGlobal_fval(arg1 Foo) {
|
||||
_swig_wrap_Bar_global_fval_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_global_fval_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_global_fval_get() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_global_fval_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetBarGlobal_fval() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_global_fval_get()
|
||||
}
|
||||
|
||||
var _wrap_Bar_test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_test(base SwigcptrBar, _ int, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Test(arg2 int, arg3 Foo) (_swig_ret int) {
|
||||
return _swig_wrap_Bar_test(arg1, arg2, arg3.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_testFoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_testFoo(base SwigcptrBar, _ int, _ uintptr) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_testFoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) TestFoo(arg2 int, arg3 Foo) (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_testFoo(arg1, arg2, arg3.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
SetFptr(arg2 Foo)
|
||||
GetFptr() (_swig_ret Foo)
|
||||
SetFref(arg2 Foo)
|
||||
GetFref() (_swig_ret Foo)
|
||||
SetFval(arg2 Foo)
|
||||
GetFval() (_swig_ret Foo)
|
||||
GetCint() (_swig_ret int)
|
||||
Test(arg2 int, arg3 Foo) (_swig_ret int)
|
||||
TestFoo(arg2 int, arg3 Foo) (_swig_ret Foo)
|
||||
}
|
||||
|
||||
var _wrap_get_func1_ptr unsafe.Pointer
|
||||
|
||||
func Get_func1_ptr() (_swig_ret _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_get_func1_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_get_func2_ptr unsafe.Pointer
|
||||
|
||||
func Get_func2_ptr() (_swig_ret _swig_memberptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_get_func2_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_test_func_ptr unsafe.Pointer
|
||||
|
||||
func _swig_wrap_test_func_ptr(base uintptr, _ int) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_test_func_ptr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Test_func_ptr(arg1 Foo, arg2 int) (_swig_ret int) {
|
||||
return _swig_wrap_test_func_ptr(arg1.Swigcptr(), arg2)
|
||||
}
|
||||
|
||||
type SwigcptrFl_Window uintptr
|
||||
|
||||
func (p SwigcptrFl_Window) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFl_Window) SwigIsFl_Window() {
|
||||
}
|
||||
|
||||
var _wrap_new_Fl_Window unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Fl_Window() (base SwigcptrFl_Window) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Fl_Window, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFl_Window() (_swig_ret Fl_Window) {
|
||||
return _swig_wrap_new_Fl_Window()
|
||||
}
|
||||
|
||||
var _wrap_delete_Fl_Window unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Fl_Window(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Fl_Window, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFl_Window(arg1 Fl_Window) {
|
||||
_swig_wrap_delete_Fl_Window(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Fl_Window_show__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Fl_Window_show__SWIG_0(base SwigcptrFl_Window, _ uintptr, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Fl_Window_show__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFl_Window) Show__SWIG_0(arg2 uintptr, arg3 uintptr) {
|
||||
_swig_wrap_Fl_Window_show__SWIG_0(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_Fl_Window_show__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Fl_Window_show__SWIG_1(base SwigcptrFl_Window, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Fl_Window_show__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFl_Window) Show__SWIG_1(arg2 uintptr) {
|
||||
_swig_wrap_Fl_Window_show__SWIG_1(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Fl_Window_show__SWIG_2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Fl_Window_show__SWIG_2(base SwigcptrFl_Window) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Fl_Window_show__SWIG_2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFl_Window) Show__SWIG_2() {
|
||||
_swig_wrap_Fl_Window_show__SWIG_2(arg1)
|
||||
}
|
||||
|
||||
func (p SwigcptrFl_Window) Show(a ...interface{}) {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
p.Show__SWIG_2()
|
||||
return
|
||||
}
|
||||
if argc == 1 {
|
||||
p.Show__SWIG_1(a[0].(uintptr))
|
||||
return
|
||||
}
|
||||
if argc == 2 {
|
||||
p.Show__SWIG_0(a[0].(uintptr), a[1].(uintptr))
|
||||
return
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
type Fl_Window interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFl_Window()
|
||||
Show(a ...interface{})
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,354 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_enum.i
|
||||
|
||||
package cpp_enum
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SOME_ENUM int
|
||||
var _wrap_ENUM_ONE unsafe.Pointer
|
||||
|
||||
func _swig_getENUM_ONE() (_swig_ret SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ENUM_ONE, _swig_p)
|
||||
return
|
||||
}
|
||||
var ENUM_ONE SOME_ENUM = _swig_getENUM_ONE()
|
||||
var _wrap_ENUM_TWO unsafe.Pointer
|
||||
|
||||
func _swig_getENUM_TWO() (_swig_ret SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_ENUM_TWO, _swig_p)
|
||||
return
|
||||
}
|
||||
var ENUM_TWO SOME_ENUM = _swig_getENUM_TWO()
|
||||
type SwigcptrStructWithEnums uintptr
|
||||
|
||||
func (p SwigcptrStructWithEnums) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrStructWithEnums) SwigIsStructWithEnums() {
|
||||
}
|
||||
|
||||
var _wrap_new_StructWithEnums unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_StructWithEnums() (base SwigcptrStructWithEnums) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_StructWithEnums, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewStructWithEnums() (_swig_ret StructWithEnums) {
|
||||
return _swig_wrap_new_StructWithEnums()
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_some_enum_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_some_enum_set(base SwigcptrStructWithEnums, _ SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_some_enum_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) SetSome_enum(arg2 SOME_ENUM) {
|
||||
_swig_wrap_StructWithEnums_some_enum_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_some_enum_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_some_enum_get(base SwigcptrStructWithEnums) (_ SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_some_enum_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) GetSome_enum() (_swig_ret SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_some_enum_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test1(base SwigcptrStructWithEnums, _ SOME_ENUM, _ *SOME_ENUM, _ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test1(arg2 SOME_ENUM, arg3 *SOME_ENUM, arg4 *SOME_ENUM) {
|
||||
_swig_wrap_StructWithEnums_enum_test1(arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test2(base SwigcptrStructWithEnums, _ SOME_ENUM, _ *SOME_ENUM, _ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test2(arg2 SOME_ENUM, arg3 *SOME_ENUM, arg4 *SOME_ENUM) {
|
||||
_swig_wrap_StructWithEnums_enum_test2(arg1, arg2, arg3, arg4)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test3(base SwigcptrStructWithEnums) (_ SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test3() (_swig_ret SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test3(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test4(base SwigcptrStructWithEnums) (_ SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test4() (_swig_ret SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test4(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test5(base SwigcptrStructWithEnums) (_ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test5() (_swig_ret *SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test5(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test6 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test6(base SwigcptrStructWithEnums) (_ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test6, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test6() (_swig_ret *SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test6(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test7 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test7(base SwigcptrStructWithEnums) (_ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test7, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test7() (_swig_ret *SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test7(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StructWithEnums_enum_test8 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StructWithEnums_enum_test8(base SwigcptrStructWithEnums) (_ *SOME_ENUM) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StructWithEnums_enum_test8, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrStructWithEnums) Enum_test8() (_swig_ret *SOME_ENUM) {
|
||||
return _swig_wrap_StructWithEnums_enum_test8(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_StructWithEnums unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_StructWithEnums(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_StructWithEnums, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteStructWithEnums(arg1 StructWithEnums) {
|
||||
_swig_wrap_delete_StructWithEnums(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type StructWithEnums interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsStructWithEnums()
|
||||
SetSome_enum(arg2 SOME_ENUM)
|
||||
GetSome_enum() (_swig_ret SOME_ENUM)
|
||||
Enum_test1(arg2 SOME_ENUM, arg3 *SOME_ENUM, arg4 *SOME_ENUM)
|
||||
Enum_test2(arg2 SOME_ENUM, arg3 *SOME_ENUM, arg4 *SOME_ENUM)
|
||||
Enum_test3() (_swig_ret SOME_ENUM)
|
||||
Enum_test4() (_swig_ret SOME_ENUM)
|
||||
Enum_test5() (_swig_ret *SOME_ENUM)
|
||||
Enum_test6() (_swig_ret *SOME_ENUM)
|
||||
Enum_test7() (_swig_ret *SOME_ENUM)
|
||||
Enum_test8() (_swig_ret *SOME_ENUM)
|
||||
}
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Hi_Foo unsafe.Pointer
|
||||
|
||||
func _swig_getFoo_Hi_Foo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Hi_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
var FooHi int = _swig_getFoo_Hi_Foo()
|
||||
var _wrap_Hello_Foo unsafe.Pointer
|
||||
|
||||
func _swig_getFoo_Hello_Foo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Hello_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
var FooHello int = _swig_getFoo_Hello_Foo()
|
||||
var _wrap_Foo_hola_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_hola_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_hola_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetHola(arg2 int) {
|
||||
_swig_wrap_Foo_hola_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_hola_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_hola_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_hola_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetHola() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_hola_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetHola(arg2 int)
|
||||
GetHola() (_swig_ret int)
|
||||
}
|
||||
|
||||
var _wrap_Hi unsafe.Pointer
|
||||
|
||||
func _swig_getHi() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Hi, _swig_p)
|
||||
return
|
||||
}
|
||||
var Hi int = _swig_getHi()
|
||||
var _wrap_Hello unsafe.Pointer
|
||||
|
||||
func _swig_getHello() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Hello, _swig_p)
|
||||
return
|
||||
}
|
||||
var Hello int = _swig_getHello()
|
||||
var _wrap_hi_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_hi_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_hi_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetHi(arg1 int) {
|
||||
_swig_wrap_hi_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_hi_get unsafe.Pointer
|
||||
|
||||
func GetHi() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_hi_get, _swig_p)
|
||||
return
|
||||
}
|
||||
type Play_state int
|
||||
var _wrap_PLAY unsafe.Pointer
|
||||
|
||||
func _swig_getPLAY() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_PLAY, _swig_p)
|
||||
return
|
||||
}
|
||||
var PLAY int = _swig_getPLAY()
|
||||
var _wrap_STOP unsafe.Pointer
|
||||
|
||||
func _swig_getSTOP() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_STOP, _swig_p)
|
||||
return
|
||||
}
|
||||
var STOP int = _swig_getSTOP()
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,418 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_namespace.i
|
||||
|
||||
package cpp_namespace
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
var _wrap_fact unsafe.Pointer
|
||||
|
||||
func Fact(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_fact, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_Foo_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetFoo(arg1 int) {
|
||||
_swig_wrap_Foo_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_get unsafe.Pointer
|
||||
|
||||
func GetFoo() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_get, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrTest uintptr
|
||||
|
||||
func (p SwigcptrTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest) SwigIsTest() {
|
||||
}
|
||||
|
||||
var _wrap_new_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test() (base SwigcptrTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest() (_swig_ret Test) {
|
||||
return _swig_wrap_new_Test()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest(arg1 Test) {
|
||||
_swig_wrap_delete_Test(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Test_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_method(base SwigcptrTest) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Method() (_swig_ret string) {
|
||||
return _swig_wrap_Test_method(arg1)
|
||||
}
|
||||
|
||||
type Test interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest()
|
||||
Method() (_swig_ret string)
|
||||
}
|
||||
|
||||
var _wrap_weird unsafe.Pointer
|
||||
|
||||
func _swig_wrap_weird(base string, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_weird, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Weird(arg1 string, arg2 int) {
|
||||
_swig_wrap_weird(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_do_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_do_method(base uintptr) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_do_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Do_method(arg1 Test) (_swig_ret string) {
|
||||
return _swig_wrap_do_method(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_do_method2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_do_method2(base uintptr) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_do_method2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Do_method2(arg1 Test) (_swig_ret string) {
|
||||
return _swig_wrap_do_method2(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type SwigcptrTest2 uintptr
|
||||
|
||||
func (p SwigcptrTest2) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest2) SwigIsTest2() {
|
||||
}
|
||||
|
||||
var _wrap_delete_Test2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test2(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest2(arg1 Test2) {
|
||||
_swig_wrap_delete_Test2(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Test2_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test2_method(base SwigcptrTest2) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test2_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest2) Method() (_swig_ret string) {
|
||||
return _swig_wrap_Test2_method(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Test2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test2() (base SwigcptrTest2) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest2() (_swig_ret Test2) {
|
||||
return _swig_wrap_new_Test2()
|
||||
}
|
||||
|
||||
type Test2 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest2()
|
||||
Method() (_swig_ret string)
|
||||
}
|
||||
|
||||
type SwigcptrTest3 uintptr
|
||||
|
||||
func (p SwigcptrTest3) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest3) SwigIsTest3() {
|
||||
}
|
||||
|
||||
var _wrap_Test3_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test3_method(base SwigcptrTest3) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test3_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest3) Method() (_swig_ret string) {
|
||||
return _swig_wrap_Test3_method(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Test3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test3() (base SwigcptrTest3) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest3() (_swig_ret Test3) {
|
||||
return _swig_wrap_new_Test3()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test3(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest3(arg1 Test3) {
|
||||
_swig_wrap_delete_Test3(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrTest3) SwigIsTest2() {
|
||||
}
|
||||
|
||||
func (p SwigcptrTest3) SwigGetTest2() Test2 {
|
||||
return SwigcptrTest2(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Test3 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest3()
|
||||
Method() (_swig_ret string)
|
||||
SwigIsTest2()
|
||||
SwigGetTest2() Test2
|
||||
}
|
||||
|
||||
type SwigcptrTest4 uintptr
|
||||
|
||||
func (p SwigcptrTest4) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest4) SwigIsTest4() {
|
||||
}
|
||||
|
||||
var _wrap_Test4_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test4_method(base SwigcptrTest4) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test4_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest4) Method() (_swig_ret string) {
|
||||
return _swig_wrap_Test4_method(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Test4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test4() (base SwigcptrTest4) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest4() (_swig_ret Test4) {
|
||||
return _swig_wrap_new_Test4()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test4(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest4(arg1 Test4) {
|
||||
_swig_wrap_delete_Test4(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrTest4) SwigIsTest3() {
|
||||
}
|
||||
|
||||
func (p SwigcptrTest4) SwigGetTest3() Test3 {
|
||||
return SwigcptrTest3(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrTest4) SwigIsTest2() {
|
||||
}
|
||||
|
||||
func (p SwigcptrTest4) SwigGetTest2() Test2 {
|
||||
return SwigcptrTest2(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Test4 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest4()
|
||||
Method() (_swig_ret string)
|
||||
SwigIsTest3()
|
||||
SwigGetTest3() Test3
|
||||
SwigIsTest2()
|
||||
SwigGetTest2() Test2
|
||||
}
|
||||
|
||||
var _wrap_foo3 unsafe.Pointer
|
||||
|
||||
func Foo3(arg1 int) (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_foo3, _swig_p)
|
||||
return
|
||||
}
|
||||
type SwigcptrTest5 uintptr
|
||||
|
||||
func (p SwigcptrTest5) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest5) SwigIsTest5() {
|
||||
}
|
||||
|
||||
var _wrap_Test5_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test5_method(base SwigcptrTest5) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test5_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest5) Method() (_swig_ret string) {
|
||||
return _swig_wrap_Test5_method(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Test5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test5() (base SwigcptrTest5) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest5() (_swig_ret Test5) {
|
||||
return _swig_wrap_new_Test5()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test5 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test5(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test5, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest5(arg1 Test5) {
|
||||
_swig_wrap_delete_Test5(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrTest5) SwigIsTest3() {
|
||||
}
|
||||
|
||||
func (p SwigcptrTest5) SwigGetTest3() Test3 {
|
||||
return SwigcptrTest3(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrTest5) SwigIsTest2() {
|
||||
}
|
||||
|
||||
func (p SwigcptrTest5) SwigGetTest2() Test2 {
|
||||
return SwigcptrTest2(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Test5 interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest5()
|
||||
Method() (_swig_ret string)
|
||||
SwigIsTest3()
|
||||
SwigGetTest3() Test3
|
||||
SwigIsTest2()
|
||||
SwigGetTest2() Test2
|
||||
}
|
||||
|
||||
var _wrap_do_method3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_do_method3(base uintptr, _ int) (_ string) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_do_method3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Do_method3(arg1 Test2, arg2 int) (_swig_ret string) {
|
||||
return _swig_wrap_do_method3(arg1.Swigcptr(), arg2)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,213 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_nodefault.i
|
||||
|
||||
package cpp_nodefault
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_a_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_a_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_a_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetA(arg2 int) {
|
||||
_swig_wrap_Foo_a_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_a_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_a_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_a_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetA() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_a_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo(base int, _ int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo(arg1 int, arg2 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetA(arg2 int)
|
||||
GetA() (_swig_ret int)
|
||||
}
|
||||
|
||||
var _wrap_create unsafe.Pointer
|
||||
|
||||
func _swig_wrap_create(base int, _ int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_create, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Create(arg1 int, arg2 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_create(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_consume unsafe.Pointer
|
||||
|
||||
func _swig_wrap_consume(base uintptr, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_consume, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Consume(arg1 Foo, arg2 Foo) {
|
||||
_swig_wrap_consume(arg1.Swigcptr(), arg2.Swigcptr())
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_consume unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_consume(base SwigcptrBar, _ uintptr, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_consume, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Consume(arg2 Foo, arg3 Foo) {
|
||||
_swig_wrap_Bar_consume(arg1, arg2.Swigcptr(), arg3.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_create unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_create(base SwigcptrBar, _ int, _ int) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_create, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) Create(arg2 int, arg3 int) (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_create(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
Consume(arg2 Foo, arg3 Foo)
|
||||
Create(arg2 int, arg3 int) (_swig_ret Foo)
|
||||
}
|
||||
|
||||
var _wrap_gvar_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_gvar_set(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_gvar_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetGvar(arg1 Foo) {
|
||||
_swig_wrap_gvar_set(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_gvar_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_gvar_get() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_gvar_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GetGvar() (_swig_ret Foo) {
|
||||
return _swig_wrap_gvar_get()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,168 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_static.i
|
||||
|
||||
package cpp_static
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrStaticMemberTest uintptr
|
||||
|
||||
func (p SwigcptrStaticMemberTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrStaticMemberTest) SwigIsStaticMemberTest() {
|
||||
}
|
||||
|
||||
var _wrap_StaticMemberTest_static_int_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StaticMemberTest_static_int_set(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StaticMemberTest_static_int_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func SetStaticMemberTestStatic_int(arg1 int) {
|
||||
_swig_wrap_StaticMemberTest_static_int_set(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StaticMemberTest_static_int_get unsafe.Pointer
|
||||
|
||||
func GetStaticMemberTestStatic_int() (_swig_ret int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&_swig_ret))
|
||||
_cgo_runtime_cgocall(_wrap_StaticMemberTest_static_int_get, _swig_p)
|
||||
return
|
||||
}
|
||||
var _wrap_new_StaticMemberTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_StaticMemberTest() (base SwigcptrStaticMemberTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_StaticMemberTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewStaticMemberTest() (_swig_ret StaticMemberTest) {
|
||||
return _swig_wrap_new_StaticMemberTest()
|
||||
}
|
||||
|
||||
var _wrap_delete_StaticMemberTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_StaticMemberTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_StaticMemberTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteStaticMemberTest(arg1 StaticMemberTest) {
|
||||
_swig_wrap_delete_StaticMemberTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type StaticMemberTest interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsStaticMemberTest()
|
||||
}
|
||||
|
||||
type SwigcptrStaticFunctionTest uintptr
|
||||
|
||||
func (p SwigcptrStaticFunctionTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrStaticFunctionTest) SwigIsStaticFunctionTest() {
|
||||
}
|
||||
|
||||
var _wrap_StaticFunctionTest_static_func unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StaticFunctionTest_static_func() {
|
||||
var _swig_p uintptr
|
||||
_cgo_runtime_cgocall(_wrap_StaticFunctionTest_static_func, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func StaticFunctionTestStatic_func() {
|
||||
_swig_wrap_StaticFunctionTest_static_func()
|
||||
}
|
||||
|
||||
var _wrap_StaticFunctionTest_static_func_2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StaticFunctionTest_static_func_2(base int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StaticFunctionTest_static_func_2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func StaticFunctionTestStatic_func_2(arg1 int) {
|
||||
_swig_wrap_StaticFunctionTest_static_func_2(arg1)
|
||||
}
|
||||
|
||||
var _wrap_StaticFunctionTest_static_func_3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_StaticFunctionTest_static_func_3(base int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_StaticFunctionTest_static_func_3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func StaticFunctionTestStatic_func_3(arg1 int, arg2 int) {
|
||||
_swig_wrap_StaticFunctionTest_static_func_3(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_StaticFunctionTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_StaticFunctionTest() (base SwigcptrStaticFunctionTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_StaticFunctionTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewStaticFunctionTest() (_swig_ret StaticFunctionTest) {
|
||||
return _swig_wrap_new_StaticFunctionTest()
|
||||
}
|
||||
|
||||
var _wrap_delete_StaticFunctionTest unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_StaticFunctionTest(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_StaticFunctionTest, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteStaticFunctionTest(arg1 StaticFunctionTest) {
|
||||
_swig_wrap_delete_StaticFunctionTest(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type StaticFunctionTest interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsStaticFunctionTest()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
Binary file not shown.
|
|
@ -1,352 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../cpp_typedef.i
|
||||
|
||||
package cpp_typedef
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_bar(base SwigcptrFoo) (_ SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Bar() (_swig_ret Bar) {
|
||||
return _swig_wrap_Foo_bar(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_sbar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_sbar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_sbar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func FooSbar() (_swig_ret Bar) {
|
||||
return _swig_wrap_Foo_sbar()
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
Bar() (_swig_ret Bar)
|
||||
}
|
||||
|
||||
type SwigcptrUnnamedStruct uintptr
|
||||
|
||||
func (p SwigcptrUnnamedStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrUnnamedStruct) SwigIsUnnamedStruct() {
|
||||
}
|
||||
|
||||
var _wrap_UnnamedStruct_something_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_UnnamedStruct_something_set(base SwigcptrUnnamedStruct, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_UnnamedStruct_something_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrUnnamedStruct) SetSomething(arg2 int) {
|
||||
_swig_wrap_UnnamedStruct_something_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_UnnamedStruct_something_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_UnnamedStruct_something_get(base SwigcptrUnnamedStruct) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_UnnamedStruct_something_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrUnnamedStruct) GetSomething() (_swig_ret int) {
|
||||
return _swig_wrap_UnnamedStruct_something_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_UnnamedStruct_m unsafe.Pointer
|
||||
|
||||
func _swig_wrap_UnnamedStruct_m(base SwigcptrUnnamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_UnnamedStruct_m, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrUnnamedStruct) M() {
|
||||
_swig_wrap_UnnamedStruct_m(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_UnnamedStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_UnnamedStruct() (base SwigcptrUnnamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_UnnamedStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewUnnamedStruct() (_swig_ret UnnamedStruct) {
|
||||
return _swig_wrap_new_UnnamedStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_UnnamedStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_UnnamedStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_UnnamedStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteUnnamedStruct(arg1 UnnamedStruct) {
|
||||
_swig_wrap_delete_UnnamedStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type UnnamedStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsUnnamedStruct()
|
||||
SetSomething(arg2 int)
|
||||
GetSomething() (_swig_ret int)
|
||||
M()
|
||||
}
|
||||
|
||||
type SwigcptrTypedefNamedStruct uintptr
|
||||
|
||||
func (p SwigcptrTypedefNamedStruct) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTypedefNamedStruct) SwigIsTypedefNamedStruct() {
|
||||
}
|
||||
|
||||
var _wrap_TypedefNamedStruct_something_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TypedefNamedStruct_something_set(base SwigcptrTypedefNamedStruct, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TypedefNamedStruct_something_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTypedefNamedStruct) SetSomething(arg2 int) {
|
||||
_swig_wrap_TypedefNamedStruct_something_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_TypedefNamedStruct_something_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TypedefNamedStruct_something_get(base SwigcptrTypedefNamedStruct) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TypedefNamedStruct_something_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTypedefNamedStruct) GetSomething() (_swig_ret int) {
|
||||
return _swig_wrap_TypedefNamedStruct_something_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_TypedefNamedStruct_m unsafe.Pointer
|
||||
|
||||
func _swig_wrap_TypedefNamedStruct_m(base SwigcptrTypedefNamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_TypedefNamedStruct_m, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTypedefNamedStruct) M() {
|
||||
_swig_wrap_TypedefNamedStruct_m(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_TypedefNamedStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_TypedefNamedStruct() (base SwigcptrTypedefNamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_TypedefNamedStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTypedefNamedStruct() (_swig_ret TypedefNamedStruct) {
|
||||
return _swig_wrap_new_TypedefNamedStruct()
|
||||
}
|
||||
|
||||
var _wrap_delete_TypedefNamedStruct unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_TypedefNamedStruct(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_TypedefNamedStruct, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTypedefNamedStruct(arg1 TypedefNamedStruct) {
|
||||
_swig_wrap_delete_TypedefNamedStruct(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type TypedefNamedStruct interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTypedefNamedStruct()
|
||||
SetSomething(arg2 int)
|
||||
GetSomething() (_swig_ret int)
|
||||
M()
|
||||
}
|
||||
|
||||
type SwigcptrTest uintptr
|
||||
|
||||
func (p SwigcptrTest) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrTest) SwigIsTest() {
|
||||
}
|
||||
|
||||
var _wrap_Test_test1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_test1(base SwigcptrTest, _ uintptr) (_ SwigcptrUnnamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_test1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Test1(arg2 UnnamedStruct) (_swig_ret UnnamedStruct) {
|
||||
return _swig_wrap_Test_test1(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Test_test2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_test2(base SwigcptrTest, _ uintptr) (_ SwigcptrTypedefNamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_test2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Test2(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct) {
|
||||
return _swig_wrap_Test_test2(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Test_test3 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_test3(base SwigcptrTest, _ uintptr) (_ SwigcptrTypedefNamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_test3, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Test3(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct) {
|
||||
return _swig_wrap_Test_test3(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Test_test4 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Test_test4(base SwigcptrTest, _ uintptr) (_ SwigcptrTypedefNamedStruct) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Test_test4, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrTest) Test4(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct) {
|
||||
return _swig_wrap_Test_test4(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Test() (base SwigcptrTest) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewTest() (_swig_ret Test) {
|
||||
return _swig_wrap_new_Test()
|
||||
}
|
||||
|
||||
var _wrap_delete_Test unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Test(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Test, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteTest(arg1 Test) {
|
||||
_swig_wrap_delete_Test(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Test interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsTest()
|
||||
Test1(arg2 UnnamedStruct) (_swig_ret UnnamedStruct)
|
||||
Test2(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct)
|
||||
Test3(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct)
|
||||
Test4(arg2 TypedefNamedStruct) (_swig_ret TypedefNamedStruct)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,278 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../curiously_recurring_template_pattern.i
|
||||
|
||||
package curiously_recurring_template_pattern
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrBasederived uintptr
|
||||
|
||||
func (p SwigcptrBasederived) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBasederived) SwigIsBasederived() {
|
||||
}
|
||||
|
||||
var _wrap_new_basederived unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_basederived() (base SwigcptrBasederived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_basederived, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBasederived() (_swig_ret Basederived) {
|
||||
return _swig_wrap_new_basederived()
|
||||
}
|
||||
|
||||
var _wrap_basederived_getBase1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_basederived_getBase1Param(base SwigcptrBasederived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_basederived_getBase1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBasederived) GetBase1Param() (_swig_ret int) {
|
||||
return _swig_wrap_basederived_getBase1Param(arg1)
|
||||
}
|
||||
|
||||
var _wrap_basederived_setBase1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_basederived_setBase1Param(base SwigcptrBasederived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_basederived_setBase1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBasederived) SetBase1Param(arg2 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_basederived_setBase1Param(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_basederived_getBase2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_basederived_getBase2Param(base SwigcptrBasederived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_basederived_getBase2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBasederived) GetBase2Param() (_swig_ret int) {
|
||||
return _swig_wrap_basederived_getBase2Param(arg1)
|
||||
}
|
||||
|
||||
var _wrap_basederived_setBase2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_basederived_setBase2Param(base SwigcptrBasederived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_basederived_setBase2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBasederived) SetBase2Param(arg2 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_basederived_setBase2Param(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_basederived unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_basederived(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_basederived, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBasederived(arg1 Basederived) {
|
||||
_swig_wrap_delete_basederived(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Basederived interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBasederived()
|
||||
GetBase1Param() (_swig_ret int)
|
||||
SetBase1Param(arg2 int) (_swig_ret Derived)
|
||||
GetBase2Param() (_swig_ret int)
|
||||
SetBase2Param(arg2 int) (_swig_ret Derived)
|
||||
}
|
||||
|
||||
type SwigcptrDerived uintptr
|
||||
|
||||
func (p SwigcptrDerived) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDerived) SwigIsDerived() {
|
||||
}
|
||||
|
||||
var _wrap_new_Derived unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Derived() (base SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Derived, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDerived() (_swig_ret Derived) {
|
||||
return _swig_wrap_new_Derived()
|
||||
}
|
||||
|
||||
var _wrap_Derived_getDerived1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_getDerived1Param(base SwigcptrDerived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_getDerived1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerived) GetDerived1Param() (_swig_ret int) {
|
||||
return _swig_wrap_Derived_getDerived1Param(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Derived_setDerived1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_setDerived1Param(base SwigcptrDerived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_setDerived1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerived) SetDerived1Param(arg2 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_Derived_setDerived1Param(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Derived_getDerived2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_getDerived2Param(base SwigcptrDerived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_getDerived2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerived) GetDerived2Param() (_swig_ret int) {
|
||||
return _swig_wrap_Derived_getDerived2Param(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Derived_setDerived2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_setDerived2Param(base SwigcptrDerived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_setDerived2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDerived) SetDerived2Param(arg2 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_Derived_setDerived2Param(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_Derived unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Derived(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Derived, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDerived(arg1 Derived) {
|
||||
_swig_wrap_delete_Derived(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Derived_getBase1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_getBase1Param(base SwigcptrDerived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_getBase1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerived) GetBase1Param() (_swig_ret int) {
|
||||
return _swig_wrap_Derived_getBase1Param(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_Derived_setBase1Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_setBase1Param(base SwigcptrDerived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_setBase1Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerived) SetBase1Param(arg1 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_Derived_setBase1Param(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_Derived_getBase2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_getBase2Param(base SwigcptrDerived) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_getBase2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerived) GetBase2Param() (_swig_ret int) {
|
||||
return _swig_wrap_Derived_getBase2Param(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_Derived_setBase2Param unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Derived_setBase2Param(base SwigcptrDerived, _ int) (_ SwigcptrDerived) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Derived_setBase2Param, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerived) SetBase2Param(arg1 int) (_swig_ret Derived) {
|
||||
return _swig_wrap_Derived_setBase2Param(_swig_base, arg1)
|
||||
}
|
||||
|
||||
func (p SwigcptrDerived) SwigIsBasederived() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDerived) SwigGetBasederived() Basederived {
|
||||
return SwigcptrBasederived(p.Swigcptr())
|
||||
}
|
||||
|
||||
type Derived interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDerived()
|
||||
GetDerived1Param() (_swig_ret int)
|
||||
SetDerived1Param(arg2 int) (_swig_ret Derived)
|
||||
GetDerived2Param() (_swig_ret int)
|
||||
SetDerived2Param(arg2 int) (_swig_ret Derived)
|
||||
GetBase1Param() (_swig_ret int)
|
||||
SetBase1Param(arg1 int) (_swig_ret Derived)
|
||||
GetBase2Param() (_swig_ret int)
|
||||
SetBase2Param(arg1 int) (_swig_ret Derived)
|
||||
SwigIsBasederived()
|
||||
SwigGetBasederived() Basederived
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,154 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../default_arg_values.i
|
||||
|
||||
package default_arg_values
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrDisplay uintptr
|
||||
|
||||
func (p SwigcptrDisplay) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDisplay) SwigIsDisplay() {
|
||||
}
|
||||
|
||||
var _wrap_Display_draw1__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Display_draw1__SWIG_0(base SwigcptrDisplay, _ float32) (_ float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Display_draw1__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDisplay) Draw1__SWIG_0(arg2 float32) (_swig_ret float32) {
|
||||
return _swig_wrap_Display_draw1__SWIG_0(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Display_draw1__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Display_draw1__SWIG_1(base SwigcptrDisplay) (_ float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Display_draw1__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDisplay) Draw1__SWIG_1() (_swig_ret float32) {
|
||||
return _swig_wrap_Display_draw1__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
func (p SwigcptrDisplay) Draw1(a ...interface{}) float32 {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return p.Draw1__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return p.Draw1__SWIG_0(a[0].(float32))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_Display_draw2__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Display_draw2__SWIG_0(base SwigcptrDisplay, _ *float32) (_ float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Display_draw2__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDisplay) Draw2__SWIG_0(arg2 *float32) (_swig_ret float32) {
|
||||
return _swig_wrap_Display_draw2__SWIG_0(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Display_draw2__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Display_draw2__SWIG_1(base SwigcptrDisplay) (_ float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Display_draw2__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrDisplay) Draw2__SWIG_1() (_swig_ret float32) {
|
||||
return _swig_wrap_Display_draw2__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
func (p SwigcptrDisplay) Draw2(a ...interface{}) float32 {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return p.Draw2__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return p.Draw2__SWIG_0(a[0].(*float32))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_new_Display unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Display() (base SwigcptrDisplay) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Display, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDisplay() (_swig_ret Display) {
|
||||
return _swig_wrap_new_Display()
|
||||
}
|
||||
|
||||
var _wrap_delete_Display unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Display(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Display, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDisplay(arg1 Display) {
|
||||
_swig_wrap_delete_Display(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Display interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDisplay()
|
||||
Draw1(a ...interface{}) float32
|
||||
Draw2(a ...interface{}) float32
|
||||
}
|
||||
|
||||
var _wrap_createPtr unsafe.Pointer
|
||||
|
||||
func CreatePtr(arg1 float32) (_swig_ret *float32) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&arg1))
|
||||
_cgo_runtime_cgocall(_wrap_createPtr, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load diff
Binary file not shown.
|
|
@ -1,902 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../default_constructor.i
|
||||
|
||||
package default_constructor
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
}
|
||||
|
||||
type SwigcptrAA uintptr
|
||||
|
||||
func (p SwigcptrAA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAA) SwigIsAA() {
|
||||
}
|
||||
|
||||
var _wrap_new_AA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_AA() (base SwigcptrAA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_AA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewAA() (_swig_ret AA) {
|
||||
return _swig_wrap_new_AA()
|
||||
}
|
||||
|
||||
var _wrap_delete_AA unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_AA(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_AA, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAA(arg1 AA) {
|
||||
_swig_wrap_delete_AA(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrAA) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrAA) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type AA interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAA()
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B(base int, _ int) (_ SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB(arg1 int, arg2 int) (_swig_ret B) {
|
||||
return _swig_wrap_new_B(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
}
|
||||
|
||||
type SwigcptrBB uintptr
|
||||
|
||||
func (p SwigcptrBB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBB) SwigIsBB() {
|
||||
}
|
||||
|
||||
var _wrap_delete_BB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_BB(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_BB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBB(arg1 BB) {
|
||||
_swig_wrap_delete_BB(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrBB) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrBB) SwigGetB() B {
|
||||
return SwigcptrB(p.Swigcptr())
|
||||
}
|
||||
|
||||
type BB interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBB()
|
||||
SwigIsB()
|
||||
SwigGetB() B
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
}
|
||||
|
||||
type SwigcptrCC uintptr
|
||||
|
||||
func (p SwigcptrCC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrCC) SwigIsCC() {
|
||||
}
|
||||
|
||||
var _wrap_new_CC unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_CC() (base SwigcptrCC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_CC, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewCC() (_swig_ret CC) {
|
||||
return _swig_wrap_new_CC()
|
||||
}
|
||||
|
||||
var _wrap_delete_CC unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_CC(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_CC, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteCC(arg1 CC) {
|
||||
_swig_wrap_delete_CC(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrCC) SwigIsC() {
|
||||
}
|
||||
|
||||
func (p SwigcptrCC) SwigGetC() C {
|
||||
return SwigcptrC(p.Swigcptr())
|
||||
}
|
||||
|
||||
type CC interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsCC()
|
||||
SwigIsC()
|
||||
SwigGetC() C
|
||||
}
|
||||
|
||||
type SwigcptrD uintptr
|
||||
|
||||
func (p SwigcptrD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrD) SwigIsD() {
|
||||
}
|
||||
|
||||
var _wrap_D_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_D_foo(base SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_D_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrD) Foo() {
|
||||
_swig_wrap_D_foo(arg1)
|
||||
}
|
||||
|
||||
var _wrap_delete_D unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_D(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_D, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteD(arg1 D) {
|
||||
_swig_wrap_delete_D(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type D interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsD()
|
||||
Foo()
|
||||
}
|
||||
|
||||
type SwigcptrDD uintptr
|
||||
|
||||
func (p SwigcptrDD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDD) SwigIsDD() {
|
||||
}
|
||||
|
||||
var _wrap_delete_DD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_DD(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_DD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDD(arg1 DD) {
|
||||
_swig_wrap_delete_DD(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_DD_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DD_foo(base SwigcptrDD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DD_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDD) Foo() {
|
||||
_swig_wrap_DD_foo(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrDD) SwigIsD() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDD) SwigGetD() D {
|
||||
return SwigcptrD(p.Swigcptr())
|
||||
}
|
||||
|
||||
type DD interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDD()
|
||||
Foo()
|
||||
SwigIsD()
|
||||
SwigGetD() D
|
||||
}
|
||||
|
||||
type SwigcptrAD uintptr
|
||||
|
||||
func (p SwigcptrAD) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrAD) SwigIsAD() {
|
||||
}
|
||||
|
||||
var _wrap_delete_AD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_AD(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_AD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteAD(arg1 AD) {
|
||||
_swig_wrap_delete_AD(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_AD_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_AD_foo(base SwigcptrAD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_AD_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrAD) Foo() {
|
||||
_swig_wrap_AD_foo(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrAD) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrAD) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_AD_SwigGetD unsafe.Pointer
|
||||
|
||||
func _swig_wrap_AD_SwigGetD(base SwigcptrAD) (_ SwigcptrD) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_AD_SwigGetD, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrAD) SwigGetD() (_swig_ret D) {
|
||||
return _swig_wrap_AD_SwigGetD(arg1)
|
||||
}
|
||||
|
||||
type AD interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsAD()
|
||||
Foo()
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
SwigGetD() (_swig_ret D)
|
||||
}
|
||||
|
||||
type SwigcptrE uintptr
|
||||
|
||||
func (p SwigcptrE) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrE) SwigIsE() {
|
||||
}
|
||||
|
||||
var _wrap_new_E__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E__SWIG_0(base int, _ int) (_ SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE__SWIG_0(arg1 int, arg2 int) (_swig_ret E) {
|
||||
return _swig_wrap_new_E__SWIG_0(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_new_E__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E__SWIG_1(base int) (_ SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE__SWIG_1(arg1 int) (_swig_ret E) {
|
||||
return _swig_wrap_new_E__SWIG_1(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_E__SWIG_2 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_E__SWIG_2() (base SwigcptrE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_E__SWIG_2, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewE__SWIG_2() (_swig_ret E) {
|
||||
return _swig_wrap_new_E__SWIG_2()
|
||||
}
|
||||
|
||||
func NewE(a ...interface{}) E {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewE__SWIG_2()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewE__SWIG_1(a[0].(int))
|
||||
}
|
||||
if argc == 2 {
|
||||
return NewE__SWIG_0(a[0].(int), a[1].(int))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_E unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_E(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_E, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteE(arg1 E) {
|
||||
_swig_wrap_delete_E(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type E interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsE()
|
||||
}
|
||||
|
||||
type SwigcptrEE uintptr
|
||||
|
||||
func (p SwigcptrEE) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrEE) SwigIsEE() {
|
||||
}
|
||||
|
||||
var _wrap_new_EE unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_EE() (base SwigcptrEE) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_EE, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewEE() (_swig_ret EE) {
|
||||
return _swig_wrap_new_EE()
|
||||
}
|
||||
|
||||
var _wrap_delete_EE unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_EE(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_EE, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteEE(arg1 EE) {
|
||||
_swig_wrap_delete_EE(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrEE) SwigIsE() {
|
||||
}
|
||||
|
||||
func (p SwigcptrEE) SwigGetE() E {
|
||||
return SwigcptrE(p.Swigcptr())
|
||||
}
|
||||
|
||||
type EE interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsEE()
|
||||
SwigIsE()
|
||||
SwigGetE() E
|
||||
}
|
||||
|
||||
type SwigcptrEB uintptr
|
||||
|
||||
func (p SwigcptrEB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrEB) SwigIsEB() {
|
||||
}
|
||||
|
||||
var _wrap_delete_EB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_EB(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_EB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteEB(arg1 EB) {
|
||||
_swig_wrap_delete_EB(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrEB) SwigIsE() {
|
||||
}
|
||||
|
||||
func (p SwigcptrEB) SwigGetE() E {
|
||||
return SwigcptrE(p.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_EB_SwigGetB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_EB_SwigGetB(base SwigcptrEB) (_ SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_EB_SwigGetB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrEB) SwigGetB() (_swig_ret B) {
|
||||
return _swig_wrap_EB_SwigGetB(arg1)
|
||||
}
|
||||
|
||||
type EB interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsEB()
|
||||
SwigIsE()
|
||||
SwigGetE() E
|
||||
SwigGetB() (_swig_ret B)
|
||||
}
|
||||
|
||||
type SwigcptrF uintptr
|
||||
|
||||
func (p SwigcptrF) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrF) SwigIsF() {
|
||||
}
|
||||
|
||||
var _wrap_F_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_F_foo(base SwigcptrF, _ int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_F_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrF) Foo(arg2 int, arg3 int) {
|
||||
_swig_wrap_F_foo(arg1, arg2, arg3)
|
||||
}
|
||||
|
||||
var _wrap_bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func Bar(arg1 F) {
|
||||
_swig_wrap_bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_F_destroy unsafe.Pointer
|
||||
|
||||
func _swig_wrap_F_destroy(base SwigcptrF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_F_destroy, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrF) Destroy() {
|
||||
_swig_wrap_F_destroy(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_F unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_F() (base SwigcptrF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_F, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewF() (_swig_ret F) {
|
||||
return _swig_wrap_new_F()
|
||||
}
|
||||
|
||||
type F interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsF()
|
||||
Foo(arg2 int, arg3 int)
|
||||
Destroy()
|
||||
}
|
||||
|
||||
type SwigcptrFFF uintptr
|
||||
|
||||
func (p SwigcptrFFF) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFFF) SwigIsFFF() {
|
||||
}
|
||||
|
||||
var _wrap_new_FFF unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_FFF() (base SwigcptrFFF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_FFF, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFFF() (_swig_ret FFF) {
|
||||
return _swig_wrap_new_FFF()
|
||||
}
|
||||
|
||||
var _wrap_FFF_foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FFF_foo(base SwigcptrFFF, _ int, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FFF_foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFFF) Foo(arg1 int, arg2 int) {
|
||||
_swig_wrap_FFF_foo(_swig_base, arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_FFF_destroy unsafe.Pointer
|
||||
|
||||
func _swig_wrap_FFF_destroy(base SwigcptrFFF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_FFF_destroy, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrFFF) Destroy() {
|
||||
_swig_wrap_FFF_destroy(_swig_base)
|
||||
}
|
||||
|
||||
func (p SwigcptrFFF) SwigIsF() {
|
||||
}
|
||||
|
||||
func (p SwigcptrFFF) SwigGetF() F {
|
||||
return SwigcptrF(p.Swigcptr())
|
||||
}
|
||||
|
||||
type FFF interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFFF()
|
||||
Foo(arg1 int, arg2 int)
|
||||
Destroy()
|
||||
SwigIsF()
|
||||
SwigGetF() F
|
||||
}
|
||||
|
||||
type SwigcptrG uintptr
|
||||
|
||||
func (p SwigcptrG) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrG) SwigIsG() {
|
||||
}
|
||||
|
||||
var _wrap_G_destroy unsafe.Pointer
|
||||
|
||||
func _swig_wrap_G_destroy(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_G_destroy, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GDestroy(arg1 G) {
|
||||
_swig_wrap_G_destroy(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_G unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_G() (base SwigcptrG) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_G, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewG() (_swig_ret G) {
|
||||
return _swig_wrap_new_G()
|
||||
}
|
||||
|
||||
type G interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsG()
|
||||
}
|
||||
|
||||
type SwigcptrGG uintptr
|
||||
|
||||
func (p SwigcptrGG) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrGG) SwigIsGG() {
|
||||
}
|
||||
|
||||
var _wrap_new_GG unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_GG() (base SwigcptrGG) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_GG, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewGG() (_swig_ret GG) {
|
||||
return _swig_wrap_new_GG()
|
||||
}
|
||||
|
||||
var _wrap_delete_GG unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_GG(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_GG, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteGG(arg1 GG) {
|
||||
_swig_wrap_delete_GG(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_GG_destroy unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GG_destroy(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GG_destroy, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func GGDestroy(arg1 G) {
|
||||
_swig_wrap_GG_destroy(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrGG) SwigIsG() {
|
||||
}
|
||||
|
||||
func (p SwigcptrGG) SwigGetG() G {
|
||||
return SwigcptrG(p.Swigcptr())
|
||||
}
|
||||
|
||||
type GG interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsGG()
|
||||
SwigIsG()
|
||||
SwigGetG() G
|
||||
}
|
||||
|
||||
type SwigcptrHH uintptr
|
||||
|
||||
func (p SwigcptrHH) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrHH) SwigIsHH() {
|
||||
}
|
||||
|
||||
var _wrap_new_HH unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_HH(base int, _ int) (_ SwigcptrHH) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_HH, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewHH(arg1 int, arg2 int) (_swig_ret HH) {
|
||||
return _swig_wrap_new_HH(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_delete_HH unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_HH(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_HH, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteHH(arg1 HH) {
|
||||
_swig_wrap_delete_HH(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type HH interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsHH()
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrVoid) SwigIsOSRSpatialReferenceShadow() {
|
||||
}
|
||||
|
||||
var _wrap_new_OSRSpatialReferenceShadow__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_OSRSpatialReferenceShadow__SWIG_0(base string) (_ SwigcptrVoid) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_OSRSpatialReferenceShadow__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewOSRSpatialReferenceShadow__SWIG_0(arg1 string) (_swig_ret OSRSpatialReferenceShadow) {
|
||||
return _swig_wrap_new_OSRSpatialReferenceShadow__SWIG_0(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_OSRSpatialReferenceShadow__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_OSRSpatialReferenceShadow__SWIG_1() (base SwigcptrVoid) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_OSRSpatialReferenceShadow__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewOSRSpatialReferenceShadow__SWIG_1() (_swig_ret OSRSpatialReferenceShadow) {
|
||||
return _swig_wrap_new_OSRSpatialReferenceShadow__SWIG_1()
|
||||
}
|
||||
|
||||
func NewOSRSpatialReferenceShadow(a ...interface{}) {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
NewOSRSpatialReferenceShadow__SWIG_1()
|
||||
return
|
||||
}
|
||||
if argc == 1 {
|
||||
NewOSRSpatialReferenceShadow__SWIG_0(a[0].(string))
|
||||
return
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_OSRSpatialReferenceShadow unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_OSRSpatialReferenceShadow(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_OSRSpatialReferenceShadow, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteOSRSpatialReferenceShadow(arg1 OSRSpatialReferenceShadow) {
|
||||
_swig_wrap_delete_OSRSpatialReferenceShadow(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type OSRSpatialReferenceShadow interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsOSRSpatialReferenceShadow()
|
||||
}
|
||||
|
||||
|
||||
Binary file not shown.
|
|
@ -1,136 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../defvalue_constructor.i
|
||||
|
||||
package defvalue_constructor
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
}
|
||||
|
||||
type SwigcptrBaz uintptr
|
||||
|
||||
func (p SwigcptrBaz) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBaz) SwigIsBaz() {
|
||||
}
|
||||
|
||||
var _wrap_new_Baz__SWIG_0 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Baz__SWIG_0(base uintptr) (_ SwigcptrBaz) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Baz__SWIG_0, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBaz__SWIG_0(arg1 Bar) (_swig_ret Baz) {
|
||||
return _swig_wrap_new_Baz__SWIG_0(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_Baz__SWIG_1 unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Baz__SWIG_1() (base SwigcptrBaz) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Baz__SWIG_1, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBaz__SWIG_1() (_swig_ret Baz) {
|
||||
return _swig_wrap_new_Baz__SWIG_1()
|
||||
}
|
||||
|
||||
func NewBaz(a ...interface{}) Baz {
|
||||
argc := len(a)
|
||||
if argc == 0 {
|
||||
return NewBaz__SWIG_1()
|
||||
}
|
||||
if argc == 1 {
|
||||
return NewBaz__SWIG_0(a[0].(Bar))
|
||||
}
|
||||
panic("No match for overloaded function call")
|
||||
}
|
||||
|
||||
var _wrap_delete_Baz unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Baz(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Baz, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBaz(arg1 Baz) {
|
||||
_swig_wrap_delete_Baz(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Baz interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBaz()
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,316 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../derived_byvalue.i
|
||||
|
||||
package derived_byvalue
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrFoo uintptr
|
||||
|
||||
func (p SwigcptrFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
var _wrap_Foo_x_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_x_set(base SwigcptrFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_x_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) SetX(arg2 int) {
|
||||
_swig_wrap_Foo_x_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_Foo_x_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_x_get(base SwigcptrFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_x_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) GetX() (_swig_ret int) {
|
||||
return _swig_wrap_Foo_x_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Foo_rmethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_rmethod(base SwigcptrFoo, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_rmethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Rmethod(arg2 Foo) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_rmethod(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Foo_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Foo_method(base SwigcptrFoo, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Foo_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrFoo) Method(arg2 Foo) (_swig_ret int) {
|
||||
return _swig_wrap_Foo_method(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Foo() (base SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewFoo() (_swig_ret Foo) {
|
||||
return _swig_wrap_new_Foo()
|
||||
}
|
||||
|
||||
var _wrap_delete_Foo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Foo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteFoo(arg1 Foo) {
|
||||
_swig_wrap_delete_Foo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Foo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsFoo()
|
||||
SetX(arg2 int)
|
||||
GetX() (_swig_ret int)
|
||||
Rmethod(arg2 Foo) (_swig_ret int)
|
||||
Method(arg2 Foo) (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrBar uintptr
|
||||
|
||||
func (p SwigcptrBar) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBar) SwigIsBar() {
|
||||
}
|
||||
|
||||
var _wrap_Bar_a_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_a_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_a_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetA(arg2 Foo) {
|
||||
_swig_wrap_Bar_a_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_a_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_a_get(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_a_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetA() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_a_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_Bar_b_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_b_set(base SwigcptrBar, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_b_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) SetB(arg2 Foo) {
|
||||
_swig_wrap_Bar_b_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_Bar_b_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_Bar_b_get(base SwigcptrBar) (_ SwigcptrFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_Bar_b_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBar) GetB() (_swig_ret Foo) {
|
||||
return _swig_wrap_Bar_b_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_Bar() (base SwigcptrBar) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBar() (_swig_ret Bar) {
|
||||
return _swig_wrap_new_Bar()
|
||||
}
|
||||
|
||||
var _wrap_delete_Bar unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_Bar(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBar(arg1 Bar) {
|
||||
_swig_wrap_delete_Bar(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type Bar interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBar()
|
||||
SetA(arg2 Foo)
|
||||
GetA() (_swig_ret Foo)
|
||||
SetB(arg2 Foo)
|
||||
GetB() (_swig_ret Foo)
|
||||
}
|
||||
|
||||
type SwigcptrDerFoo uintptr
|
||||
|
||||
func (p SwigcptrDerFoo) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrDerFoo) SwigIsDerFoo() {
|
||||
}
|
||||
|
||||
var _wrap_new_DerFoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_DerFoo() (base SwigcptrDerFoo) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_DerFoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewDerFoo() (_swig_ret DerFoo) {
|
||||
return _swig_wrap_new_DerFoo()
|
||||
}
|
||||
|
||||
var _wrap_delete_DerFoo unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_DerFoo(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_DerFoo, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteDerFoo(arg1 DerFoo) {
|
||||
_swig_wrap_delete_DerFoo(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_SetDerFoo_X unsafe.Pointer
|
||||
|
||||
func _swig_wrap_SetDerFoo_X(base SwigcptrDerFoo, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_SetDerFoo_X, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerFoo) SetX(arg1 int) {
|
||||
_swig_wrap_SetDerFoo_X(_swig_base, arg1)
|
||||
}
|
||||
|
||||
var _wrap_GetDerFoo_X unsafe.Pointer
|
||||
|
||||
func _swig_wrap_GetDerFoo_X(base SwigcptrDerFoo) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_GetDerFoo_X, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerFoo) GetX() (_swig_ret int) {
|
||||
return _swig_wrap_GetDerFoo_X(_swig_base)
|
||||
}
|
||||
|
||||
var _wrap_DerFoo_rmethod unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerFoo_rmethod(base SwigcptrDerFoo, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerFoo_rmethod, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerFoo) Rmethod(arg1 Foo) (_swig_ret int) {
|
||||
return _swig_wrap_DerFoo_rmethod(_swig_base, arg1.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_DerFoo_method unsafe.Pointer
|
||||
|
||||
func _swig_wrap_DerFoo_method(base SwigcptrDerFoo, _ uintptr) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_DerFoo_method, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (_swig_base SwigcptrDerFoo) Method(arg1 Foo) (_swig_ret int) {
|
||||
return _swig_wrap_DerFoo_method(_swig_base, arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrDerFoo) SwigIsFoo() {
|
||||
}
|
||||
|
||||
func (p SwigcptrDerFoo) SwigGetFoo() Foo {
|
||||
return SwigcptrFoo(p.Swigcptr())
|
||||
}
|
||||
|
||||
type DerFoo interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsDerFoo()
|
||||
SetX(arg1 int)
|
||||
GetX() (_swig_ret int)
|
||||
Rmethod(arg1 Foo) (_swig_ret int)
|
||||
Method(arg1 Foo) (_swig_ret int)
|
||||
SwigIsFoo()
|
||||
SwigGetFoo() Foo
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,232 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../derived_nested.i
|
||||
|
||||
package derived_nested
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_A_x_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_x_set(base SwigcptrA, _ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_x_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) SetX(arg2 int) {
|
||||
_swig_wrap_A_x_set(arg1, arg2)
|
||||
}
|
||||
|
||||
var _wrap_A_x_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_A_x_get(base SwigcptrA) (_ int) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_A_x_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrA) GetX() (_swig_ret int) {
|
||||
return _swig_wrap_A_x_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
SetX(arg2 int)
|
||||
GetX() (_swig_ret int)
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
var _wrap_new_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_B() (base SwigcptrB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewB() (_swig_ret B) {
|
||||
return _swig_wrap_new_B()
|
||||
}
|
||||
|
||||
var _wrap_delete_B unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_B(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_B, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteB(arg1 B) {
|
||||
_swig_wrap_delete_B(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
}
|
||||
|
||||
type SwigcptrBB uintptr
|
||||
|
||||
func (p SwigcptrBB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrBB) SwigIsBB() {
|
||||
}
|
||||
|
||||
var _wrap_BB_ff_instance_set unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BB_ff_instance_set(base SwigcptrBB, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BB_ff_instance_set, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBB) SetFf_instance(arg2 BB_FF) {
|
||||
_swig_wrap_BB_ff_instance_set(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_BB_ff_instance_get unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BB_ff_instance_get(base SwigcptrBB) (_ SwigcptrBB_FF) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BB_ff_instance_get, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBB) GetFf_instance() (_swig_ret BB_FF) {
|
||||
return _swig_wrap_BB_ff_instance_get(arg1)
|
||||
}
|
||||
|
||||
var _wrap_BB_useEE unsafe.Pointer
|
||||
|
||||
func _swig_wrap_BB_useEE(base SwigcptrBB, _ uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_BB_useEE, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func (arg1 SwigcptrBB) UseEE(arg2 BB_EE) {
|
||||
_swig_wrap_BB_useEE(arg1, arg2.Swigcptr())
|
||||
}
|
||||
|
||||
var _wrap_new_BB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_BB() (base SwigcptrBB) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_BB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewBB() (_swig_ret BB) {
|
||||
return _swig_wrap_new_BB()
|
||||
}
|
||||
|
||||
var _wrap_delete_BB unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_BB(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_BB, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteBB(arg1 BB) {
|
||||
_swig_wrap_delete_BB(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type BB interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsBB()
|
||||
SetFf_instance(arg2 BB_FF)
|
||||
GetFf_instance() (_swig_ret BB_FF)
|
||||
UseEE(arg2 BB_EE)
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrBB_FF uintptr
|
||||
type BB_FF interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrBB_FF) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrBB_EE uintptr
|
||||
type BB_EE interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrBB_EE) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
|
|
@ -1,154 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../destructor_reprotected.i
|
||||
|
||||
package destructor_reprotected
|
||||
|
||||
import "unsafe"
|
||||
import _ "runtime/cgo"
|
||||
|
||||
var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)
|
||||
|
||||
|
||||
|
||||
type _ unsafe.Pointer
|
||||
|
||||
|
||||
|
||||
type _swig_fnptr *byte
|
||||
type _swig_memberptr *byte
|
||||
|
||||
type SwigcptrA uintptr
|
||||
|
||||
func (p SwigcptrA) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrA) SwigIsA() {
|
||||
}
|
||||
|
||||
var _wrap_new_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_A() (base SwigcptrA) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewA() (_swig_ret A) {
|
||||
return _swig_wrap_new_A()
|
||||
}
|
||||
|
||||
var _wrap_delete_A unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_A(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_A, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteA(arg1 A) {
|
||||
_swig_wrap_delete_A(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
type A interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsA()
|
||||
}
|
||||
|
||||
type SwigcptrB uintptr
|
||||
|
||||
func (p SwigcptrB) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrB) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type B interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsB()
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
type SwigcptrC uintptr
|
||||
|
||||
func (p SwigcptrC) Swigcptr() uintptr {
|
||||
return (uintptr)(p)
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsC() {
|
||||
}
|
||||
|
||||
var _wrap_new_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_new_C() (base SwigcptrC) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_new_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func NewC() (_swig_ret C) {
|
||||
return _swig_wrap_new_C()
|
||||
}
|
||||
|
||||
var _wrap_delete_C unsafe.Pointer
|
||||
|
||||
func _swig_wrap_delete_C(base uintptr) {
|
||||
_swig_p := uintptr(unsafe.Pointer(&base))
|
||||
_cgo_runtime_cgocall(_wrap_delete_C, _swig_p)
|
||||
return
|
||||
}
|
||||
|
||||
func DeleteC(arg1 C) {
|
||||
_swig_wrap_delete_C(arg1.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsB() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetB() B {
|
||||
return SwigcptrB(p.Swigcptr())
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigIsA() {
|
||||
}
|
||||
|
||||
func (p SwigcptrC) SwigGetA() A {
|
||||
return SwigcptrA(p.Swigcptr())
|
||||
}
|
||||
|
||||
type C interface {
|
||||
Swigcptr() uintptr
|
||||
SwigIsC()
|
||||
SwigIsB()
|
||||
SwigGetB() B
|
||||
SwigIsA()
|
||||
SwigGetA() A
|
||||
}
|
||||
|
||||
|
||||
type SwigcptrVoid uintptr
|
||||
type Void interface {
|
||||
Swigcptr() uintptr;
|
||||
}
|
||||
func (p SwigcptrVoid) Swigcptr() uintptr {
|
||||
return uintptr(p)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,99 +0,0 @@
|
|||
/* ----------------------------------------------------------------------------
|
||||
* This file was automatically generated by SWIG (http://www.swig.org).
|
||||
* Version 3.0.3
|
||||
*
|
||||
* This file is not intended to be easily readable and contains a number of
|
||||
* coding conventions designed to improve portability and efficiency. Do not make
|
||||
* changes to this file unless you know what you are doing--modify the SWIG
|
||||
* interface file instead.
|
||||
* ----------------------------------------------------------------------------- */
|
||||
|
||||
// source: ./../director_abstract.i
|
||||
|
||||
#ifndef SWIG_director_abstract_WRAP_H_
|
||||
#define SWIG_director_abstract_WRAP_H_
|
||||
|
||||
class SwigDirector_Foo : public Foo
|
||||
{
|
||||
public:
|
||||
SwigDirector_Foo(void *swig_p);
|
||||
virtual ~SwigDirector_Foo();
|
||||
virtual std::string ping();
|
||||
std::string _swig_upcall_pong() {
|
||||
return Foo::pong();
|
||||
}
|
||||
virtual std::string pong();
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_Example0 : public Example0
|
||||
{
|
||||
public:
|
||||
SwigDirector_Example0(void *swig_p, int x, int y);
|
||||
SwigDirector_Example0(void *swig_p);
|
||||
virtual ~SwigDirector_Example0();
|
||||
int _swig_upcall_Color(unsigned char r, unsigned char g, unsigned char b) {
|
||||
return Example0::Color(r,g,b);
|
||||
}
|
||||
virtual int Color(unsigned char r, unsigned char g, unsigned char b);
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_Example1 : public Example1
|
||||
{
|
||||
public:
|
||||
SwigDirector_Example1(void *swig_p, int x, int y);
|
||||
SwigDirector_Example1(void *swig_p);
|
||||
virtual ~SwigDirector_Example1();
|
||||
virtual int Color(unsigned char r, unsigned char g, unsigned char b);
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_Example2 : public Example2
|
||||
{
|
||||
public:
|
||||
SwigDirector_Example2(void *swig_p, int x);
|
||||
SwigDirector_Example2(void *swig_p, int x, int y);
|
||||
virtual ~SwigDirector_Example2();
|
||||
virtual int Color(unsigned char r, unsigned char g, unsigned char b);
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_Example4 : public Example4
|
||||
{
|
||||
public:
|
||||
SwigDirector_Example4(void *swig_p);
|
||||
SwigDirector_Example4(void *swig_p, int x, int y);
|
||||
virtual ~SwigDirector_Example4();
|
||||
virtual int Color(unsigned char r, unsigned char g, unsigned char b);
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_Example3_i : public ns::Example3< int >
|
||||
{
|
||||
public:
|
||||
SwigDirector_Example3_i(void *swig_p);
|
||||
SwigDirector_Example3_i(void *swig_p, int x);
|
||||
SwigDirector_Example3_i(void *swig_p, int x, int y);
|
||||
virtual ~SwigDirector_Example3_i();
|
||||
virtual int Color(unsigned char r, unsigned char g, unsigned char b);
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
class SwigDirector_A : public A
|
||||
{
|
||||
public:
|
||||
SwigDirector_A(void *swig_p, A const &arg0);
|
||||
virtual ~SwigDirector_A();
|
||||
virtual int f();
|
||||
private:
|
||||
void *go_val;
|
||||
};
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue