From ea0afb6455c8f22000d7e106234f1985778716ea Mon Sep 17 00:00:00 2001 From: Tim Wojtulewicz Date: Wed, 4 Dec 2024 12:57:10 -0700 Subject: [PATCH] Add pre-commit hook for clang-format, fix all of the findings This uses Zeek's .clang-format file and ignores the patricia code since it's vendored in from the CAIDA project. --- .clang-format | 149 + .clang-format-ignore | 3 + .pre-commit-config.yaml | 9 + SubnetTree.cc | 117 +- SubnetTree_wrap.cc | 9367 +++++++++++++++++++++------------------ include/SubnetTree.h | 212 +- 6 files changed, 5311 insertions(+), 4546 deletions(-) create mode 100644 .clang-format create mode 100644 .clang-format-ignore diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..79cb374 --- /dev/null +++ b/.clang-format @@ -0,0 +1,149 @@ +# Copyright (c) 2020-2023 by the Zeek Project. See LICENSE for details. + +--- +Language: Cpp +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: true +AllowShortFunctionsOnASingleLine: true +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: Yes +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: true + IndentBraces: false + SplitEmptyFunction: false + SplitEmptyRecord: false + SplitEmptyNamespace: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Custom +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: false +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 120 +CommentPragmas: 'NOLINT' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Regroup + +# Include categories go like this: +# 0: reserved, since this automatically is the primary header for any .cc file +# 1: zeek-config.h +# 2: any c-style header +# 3: any c++-style header +# 4: any header that starts with "zeek/" +# 5: everything else, which should catch any of the auto-generated code from the +# build directory as well +# 6: third party doctest header +# +# Sections 0-1 and 2-3 get grouped together in their respective blocks +IncludeCategories: + - Regex: '^"zeek-config\.h"' + Priority: 1 + SortPriority: 1 + - Regex: '^"zeek/zeek-config\.h"' + Priority: 1 + SortPriority: 2 + - Regex: '^<[[:print:]]+\.(h|hh)>' + Priority: 2 + SortPriority: 2 + - Regex: '^<[[:print:]]+>' + Priority: 2 + SortPriority: 3 + - Regex: '^"zeek/3rdparty/doctest.h' + Priority: 6 + - Regex: '^"zeek/' + Priority: 4 + - Regex: '.*' + Priority: 5 + +IncludeIsMainRegex: '$' +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 4 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '^BEGIN_' +MacroBlockEnd: '^END_' +MaxEmptyLinesToKeep: 2 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 500 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 1000 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: false +SpaceAfterLogicalNot: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpacesInConditionalStatement: true +Standard: Cpp11 +StatementMacros: + - STANDARD_OPERATOR_1 +TabWidth: 4 +UseTab: Never +--- +Language: Json +... diff --git a/.clang-format-ignore b/.clang-format-ignore new file mode 100644 index 0000000..c17693b --- /dev/null +++ b/.clang-format-ignore @@ -0,0 +1,3 @@ +# patricia comes from the CAIDA/cc-common project and is formatted by them +patricia.c +include/patricia.h diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e626536..b17da76 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,3 +20,12 @@ repos: rev: v0.6.13 hooks: - id: cmake-format + + - repo: https://github.com/pre-commit/mirrors-clang-format + rev: 'v18.1.8' + hooks: + - id: clang-format + types_or: + - "c" + - "c++" + - "json" diff --git a/SubnetTree.cc b/SubnetTree.cc index 15ccbef..ae5bbc4 100644 --- a/SubnetTree.cc +++ b/SubnetTree.cc @@ -1,27 +1,23 @@ #include "SubnetTree.h" +#include +#include #include -#include #include -#include +#include #include -#include static PyObject* dummy = Py_BuildValue("s", ""); -const uint8_t v4_mapped_prefix[12] = { 0, 0, 0, 0, - 0, 0, 0, 0, - 0, 0, 0xff, 0xff }; +const uint8_t v4_mapped_prefix[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}; -inline static prefix_t* make_prefix() -{ - prefix_t* rval = (prefix_t*) malloc(sizeof(prefix_t)); +inline static prefix_t* make_prefix() { + prefix_t* rval = (prefix_t*)malloc(sizeof(prefix_t)); rval->ref_count = 1; return rval; } -inline static bool set_prefix(prefix_t* subnet, int family, inx_addr* addr, unsigned int width) -{ +inline static bool set_prefix(prefix_t* subnet, int family, inx_addr* addr, unsigned int width) { if ( ! (family == AF_INET || family == AF_INET6) ) return false; @@ -31,11 +27,10 @@ inline static bool set_prefix(prefix_t* subnet, int family, inx_addr* addr, unsi if ( family == AF_INET6 && width > 128 ) return false; - if ( family == AF_INET ) - { + if ( family == AF_INET ) { memcpy(&subnet->add.sin6, v4_mapped_prefix, sizeof(v4_mapped_prefix)); memcpy(&subnet->add.sin6.s6_addr[12], addr, sizeof(in_addr)); - } + } else if ( family == AF_INET6 ) memcpy(&subnet->add.sin6, addr, sizeof(subnet->add.sin6)); @@ -46,17 +41,16 @@ inline static bool set_prefix(prefix_t* subnet, int family, inx_addr* addr, unsi return true; } -inline static bool parse_cidr(const char *cidr, int *family, inx_addr *subnet, unsigned short *mask) -{ +inline static bool parse_cidr(const char* cidr, int* family, inx_addr* subnet, unsigned short* mask) { char buffer[40]; - const char *addr_str = 0; - const char *mask_str = 0; - char *endptr; + const char* addr_str = 0; + const char* mask_str = 0; + char* endptr; if ( ! cidr ) return false; - const char *slash = strchr(cidr, '/'); + const char* slash = strchr(cidr, '/'); if ( slash ) { int len = slash - cidr < 40 ? slash - cidr : 39; @@ -101,24 +95,16 @@ inline static bool parse_cidr(const char *cidr, int *family, inx_addr *subnet, u return true; } -void SubnetTree::PatriciaDeleteFunction(void* data) -{ - Py_DECREF(static_cast(data)); -} +void SubnetTree::PatriciaDeleteFunction(void* data) { Py_DECREF(static_cast(data)); } -SubnetTree::SubnetTree(bool arg_binary_lookup_mode) -{ +SubnetTree::SubnetTree(bool arg_binary_lookup_mode) { tree = New_Patricia(128); binary_lookup_mode = arg_binary_lookup_mode; } -SubnetTree::~SubnetTree() -{ - Destroy_Patricia(tree, SubnetTree::PatriciaDeleteFunction); -} +SubnetTree::~SubnetTree() { Destroy_Patricia(tree, SubnetTree::PatriciaDeleteFunction); } -PyObject* SubnetTree::insert(const char *cidr, PyObject* data) -{ +PyObject* SubnetTree::insert(const char* cidr, PyObject* data) { int family; inx_addr subnet; unsigned short mask; @@ -131,16 +117,14 @@ PyObject* SubnetTree::insert(const char *cidr, PyObject* data) return insert(family, subnet, mask, data); } -PyObject* SubnetTree::insert(unsigned long subnet, unsigned short mask, PyObject* data) -{ +PyObject* SubnetTree::insert(unsigned long subnet, unsigned short mask, PyObject* data) { inx_addr subnet_addr; - memcpy (&subnet_addr, &subnet, sizeof(subnet)); + memcpy(&subnet_addr, &subnet, sizeof(subnet)); return insert(AF_INET, subnet_addr, mask, data); } -PyObject* SubnetTree::insert(int family, inx_addr subnet, unsigned short mask, PyObject * data) -{ +PyObject* SubnetTree::insert(int family, inx_addr subnet, unsigned short mask, PyObject* data) { prefix_t* sn = make_prefix(); if ( ! sn ) { @@ -173,8 +157,7 @@ PyObject* SubnetTree::insert(int family, inx_addr subnet, unsigned short mask, P Py_RETURN_TRUE; } -PyObject* SubnetTree::remove(const char *cidr) -{ +PyObject* SubnetTree::remove(const char* cidr) { int family; inx_addr subnet; unsigned short mask; @@ -187,16 +170,14 @@ PyObject* SubnetTree::remove(const char *cidr) return remove(family, subnet, mask); } -PyObject* SubnetTree::remove(unsigned long addr, unsigned short mask) -{ +PyObject* SubnetTree::remove(unsigned long addr, unsigned short mask) { inx_addr subnet_addr; memcpy(&subnet_addr, &addr, sizeof(addr)); return remove(AF_INET, subnet_addr, mask); } -PyObject* SubnetTree::remove(int family, inx_addr addr, unsigned short mask) -{ +PyObject* SubnetTree::remove(int family, inx_addr addr, unsigned short mask) { prefix_t* subnet = make_prefix(); if ( ! subnet ) { @@ -231,8 +212,7 @@ PyObject* SubnetTree::remove(int family, inx_addr addr, unsigned short mask) Py_RETURN_FALSE; } -PyObject* SubnetTree::lookup(const char *cidr, int size) const -{ +PyObject* SubnetTree::lookup(const char* cidr, int size) const { int family; inx_addr subnet; unsigned short mask; @@ -262,16 +242,14 @@ PyObject* SubnetTree::lookup(const char *cidr, int size) const } } -PyObject* SubnetTree::lookup(unsigned long addr) const -{ +PyObject* SubnetTree::lookup(unsigned long addr) const { inx_addr addr_addr; memcpy(&addr_addr, &addr, sizeof(addr)); return lookup(AF_INET, addr_addr); } -PyObject* SubnetTree::lookup(int family, inx_addr addr) const -{ +PyObject* SubnetTree::lookup(int family, inx_addr addr) const { prefix_t* subnet = make_prefix(); if ( ! subnet ) { @@ -300,8 +278,7 @@ PyObject* SubnetTree::lookup(int family, inx_addr addr) const return data; } -PyObject* SubnetTree::search_all(const char *cidr, int size) const -{ +PyObject* SubnetTree::search_all(const char* cidr, int size) const { int family; inx_addr subnet; unsigned short mask; @@ -345,13 +322,13 @@ PyObject* SubnetTree::search_all(const char *cidr, int size) const return 0; } - patricia_node_t **outlist = nullptr; + patricia_node_t** outlist = nullptr; int n; int result = patricia_search_all(tree, sn, &outlist, &n); Deref_Prefix(sn); PyObject* list = PyList_New(n); - for (int i = 0; i < n; i++) { + for ( int i = 0; i < n; i++ ) { PyObject* data = (PyObject*)outlist[i]->data; Py_INCREF(data); PyList_SetItem(list, i, data); @@ -362,16 +339,15 @@ PyObject* SubnetTree::search_all(const char *cidr, int size) const return list; } -PyObject* SubnetTree::prefixes(bool ipv4_native /*=false*/, bool with_len /*=true*/) const -{ +PyObject* SubnetTree::prefixes(bool ipv4_native /*=false*/, bool with_len /*=true*/) const { char buf[INET6_ADDRSTRLEN]; char buffer[64]; bool wrote_buffer; PyObject* set = PySet_New(NULL); - patricia_node_t *node; + patricia_node_t* node; - PATRICIA_WALK (tree->head, node) { + PATRICIA_WALK(tree->head, node) { prefix_t* pf = node->prefix; PyObject* pstr = NULL; @@ -382,7 +358,7 @@ PyObject* SubnetTree::prefixes(bool ipv4_native /*=false*/, bool with_len /*=tru // https://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses) // We'll check the first 12 bytes (96 bits) of the stored address // to see if they match v4_mapped_prefix. - uint8_t* addrstart = (uint8_t*) &pf->add.sin6; + uint8_t* addrstart = (uint8_t*)&pf->add.sin6; if ( memcmp(&v4_mapped_prefix, addrstart, 12) == 0 ) { // Skip over the mapped-prefix to the IPV4 addr part. And we @@ -391,16 +367,13 @@ PyObject* SubnetTree::prefixes(bool ipv4_native /*=false*/, bool with_len /*=tru addrstart += 12; if ( with_len ) { - snprintf(buffer, sizeof buffer, "%d.%d.%d.%d/%d", - addrstart[0], addrstart[1], - addrstart[2], addrstart[3], - pf->bitlen - 96); + snprintf(buffer, sizeof buffer, "%d.%d.%d.%d/%d", addrstart[0], addrstart[1], addrstart[2], + addrstart[3], pf->bitlen - 96); } else { - snprintf(buffer, sizeof buffer, "%d.%d.%d.%d", - addrstart[0], addrstart[1], - addrstart[2], addrstart[3]); + snprintf(buffer, sizeof buffer, "%d.%d.%d.%d", addrstart[0], addrstart[1], addrstart[2], + addrstart[3]); } wrote_buffer = true; @@ -431,18 +404,12 @@ PyObject* SubnetTree::prefixes(bool ipv4_native /*=false*/, bool with_len /*=tru PySet_Add(set, pstr); Py_DECREF(pstr); - - } PATRICIA_WALK_END; + } + PATRICIA_WALK_END; return set; } -bool SubnetTree::get_binary_lookup_mode() -{ - return binary_lookup_mode; -} +bool SubnetTree::get_binary_lookup_mode() { return binary_lookup_mode; } -void SubnetTree::set_binary_lookup_mode(bool arg_binary_lookup_mode) -{ - binary_lookup_mode = arg_binary_lookup_mode; -} +void SubnetTree::set_binary_lookup_mode(bool arg_binary_lookup_mode) { binary_lookup_mode = arg_binary_lookup_mode; } diff --git a/SubnetTree_wrap.cc b/SubnetTree_wrap.cc index ad42244..ca9bd87 100644 --- a/SubnetTree_wrap.cc +++ b/SubnetTree_wrap.cc @@ -18,24 +18,38 @@ #ifdef __cplusplus /* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper { - struct SwigMovePointer { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); +template +class SwigValueWrapper { + struct SwigMovePointer { + T* ptr; + SwigMovePointer(T* p) : ptr(p) {} + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { + T* oldptr = ptr; + ptr = 0; + delete oldptr; + ptr = rhs.ptr; + rhs.ptr = 0; + return *this; + } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); + public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } + SwigValueWrapper() : pointer(0) {} + SwigValueWrapper& operator=(const T& t) { + SwigMovePointer tmp(new T(t)); + pointer = tmp; + return *this; + } + operator T&() const { return *pointer.ptr; } + T* operator&() { return pointer.ptr; } }; -template T SwigValueInit() { - return T(); +template +T SwigValueInit() { + return T(); } #endif @@ -46,112 +60,112 @@ template T SwigValueInit() { /* template workaround for compilers that cannot correctly implement the C++ standard */ #ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) +#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +#define SWIGTEMPLATEDISAMBIGUATOR template +#elif defined(__HP_aCC) /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif +#define SWIGTEMPLATEDISAMBIGUATOR template +#else +#define SWIGTEMPLATEDISAMBIGUATOR +#endif #endif /* inline attribute */ #ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif +#if defined(__cplusplus) || (defined(__GNUC__) && ! defined(__STRICT_ANSI__)) +#define SWIGINLINE inline +#else +#define SWIGINLINE +#endif #endif /* attribute recognised by some compilers to avoid 'unused' warnings */ #ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif +#if defined(__GNUC__) +#if ! (defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +#define SWIGUNUSED __attribute__((__unused__)) +#else +#define SWIGUNUSED +#endif +#elif defined(__ICC) +#define SWIGUNUSED __attribute__((__unused__)) +#else +#define SWIGUNUSED +#endif #endif #ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif +#if defined(_MSC_VER) +#pragma warning(disable : 4505) /* unreferenced local function has been removed */ +#endif #endif #ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif +#ifdef __cplusplus +#define SWIGUNUSEDPARM(p) +#else +#define SWIGUNUSEDPARM(p) p SWIGUNUSED +#endif #endif /* internal SWIG method */ #ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED +#define SWIGINTERN static SWIGUNUSED #endif /* internal inline SWIG method */ #ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#define SWIGINTERNINLINE SWIGINTERN SWIGINLINE #endif /* exporting methods */ #if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif +#if ( __GNUC__ >= 4 ) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +#ifndef GCC_HASCLASSVISIBILITY +#define GCC_HASCLASSVISIBILITY +#endif +#endif #endif #ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +#if defined(STATIC_LINKED) +#define SWIGEXPORT +#else +#define SWIGEXPORT __declspec(dllexport) +#endif +#else +#if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +#define SWIGEXPORT __attribute__((visibility("default"))) +#else +#define SWIGEXPORT +#endif +#endif #endif /* calling conventions for Windows */ #ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +#define SWIGSTDCALL __stdcall +#else +#define SWIGSTDCALL +#endif #endif /* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE +#if ! defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && ! defined(_CRT_SECURE_NO_DEPRECATE) +#define _CRT_SECURE_NO_DEPRECATE #endif /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE +#if ! defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && ! defined(_SCL_SECURE_NO_DEPRECATE) +#define _SCL_SECURE_NO_DEPRECATE #endif /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#if defined(__APPLE__) && ! defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +#define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 #endif /* Intel's compiler complains if a variable which was never initialised is @@ -160,17 +174,17 @@ template T SwigValueInit() { * See: https://github.com/swig/swig/issues/192 for more discussion. */ #ifdef __INTEL_COMPILER -# pragma warning disable 592 +#pragma warning disable 592 #endif #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) /* Use debug wrappers with the Python release dll */ -# undef _DEBUG -# include -# define _DEBUG +#undef _DEBUG +#include +#define _DEBUG #else -# include +#include #endif /* ----------------------------------------------------------------------------- @@ -186,11 +200,11 @@ template T SwigValueInit() { /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ #ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#define SWIG_QUOTE_STRING(x) #x +#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) #else -# define SWIG_TYPE_TABLE_NAME +#define SWIG_TYPE_TABLE_NAME #endif /* @@ -203,24 +217,24 @@ template T SwigValueInit() { */ #ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN +#define SWIGRUNTIME SWIGINTERN #endif #ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE #endif /* Generic buffer size */ #ifndef SWIG_BUFFER_SIZE -# define SWIG_BUFFER_SIZE 1024 +#define SWIG_BUFFER_SIZE 1024 #endif /* Flags for pointer conversions */ -#define SWIG_POINTER_DISOWN 0x1 -#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 /* Flags for new pointer objects */ -#define SWIG_POINTER_OWN 0x1 +#define SWIG_POINTER_OWN 0x1 /* @@ -258,7 +272,7 @@ template T SwigValueInit() { // success code if (SWIG_IsNewObj(res) { ... - delete *ptr; + delete *ptr; } else { ... } @@ -302,49 +316,47 @@ template T SwigValueInit() { just use the SWIG_AddCast()/SWIG_CheckState() */ -#define SWIG_OK (0) -#define SWIG_ERROR (-1) -#define SWIG_IsOK(r) (r >= 0) -#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) /* The CastRankLimit says how many bits are used for the cast rank */ -#define SWIG_CASTRANKLIMIT (1 << 8) +#define SWIG_CASTRANKLIMIT (1 << 8) /* The NewMask denotes the object was created (using new/malloc) */ -#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) /* The TmpMask is for in/out typemaps that use temporal objects */ -#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) /* Simple returning values */ -#define SWIG_BADOBJ (SWIG_ERROR) -#define SWIG_OLDOBJ (SWIG_OK) -#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) -#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) /* Check, add and del mask methods */ -#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) -#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) -#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) -#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) -#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) -#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) /* Cast-Rank Mode */ #if defined(SWIG_CASTRANK_MODE) -# ifndef SWIG_TypeRank -# define SWIG_TypeRank unsigned long -# endif -# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ -# define SWIG_MAXCASTRANK (2) -# endif -# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) -# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +#ifndef SWIG_TypeRank +#define SWIG_TypeRank unsigned long +#endif +#ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +#define SWIG_MAXCASTRANK (2) +#endif +#define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) - 1) +#define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) SWIGINTERNINLINE int SWIG_AddCast(int r) { - return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; -} -SWIGINTERNINLINE int SWIG_CheckState(int r) { - return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; } +SWIGINTERNINLINE int SWIG_CheckState(int r) { return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; } #else /* no cast-rank mode */ -# define SWIG_AddCast(r) (r) -# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#define SWIG_AddCast(r) (r) +#define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) #endif @@ -354,37 +366,37 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) { extern "C" { #endif -typedef void *(*swig_converter_func)(void *, int *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); +typedef void* (*swig_converter_func)(void*, int*); +typedef struct swig_type_info* (*swig_dycast_func)(void**); /* Structure to store information on one type */ typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ - int owndata; /* flag if the structure owns the clientdata */ + const char* name; /* mangled name of this type */ + const char* str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info* cast; /* linked list of types that can cast into this type */ + void* clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ } swig_type_info; /* Structure to store a type and conversion function used for casting */ typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ + swig_type_info* type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info* next; /* pointer to next cast in linked list */ + struct swig_cast_info* prev; /* pointer to the previous cast */ } swig_cast_info; /* Structure used to store module information * Each module generates one structure like this, and the runtime collects * all of these structures and stores them in a circularly linked list.*/ typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ + swig_type_info** types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info* next; /* Pointer to next element in circularly linked list */ + swig_type_info** type_initial; /* Array of initially generated type structures */ + swig_cast_info** cast_initial; /* Array of initially generated casting structures */ + void* clientdata; /* Language specific module data */ } swig_module_info; /* @@ -394,174 +406,169 @@ typedef struct swig_module_info { Return 0 when the two name types are equivalent, as in strncmp, but skipping ' '. */ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; - } - return (int)((l1 - f1) - (l2 - f2)); +SWIGRUNTIME int SWIG_TypeNameComp(const char* f1, const char* l1, const char* f2, const char* l2) { + for ( ; (f1 != l1) && (f2 != l2); ++f1, ++f2 ) { + while ( (*f1 == ' ') && (f1 != l1) ) + ++f1; + while ( (*f2 == ' ') && (f2 != l2) ) + ++f2; + if ( *f1 != *f2 ) + return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); } /* Check type equivalence in a name list like ||... Return 0 if equal, -1 if nb < tb, 1 if nb > tb */ -SWIGRUNTIME int -SWIG_TypeCmp(const char *nb, const char *tb) { - int equiv = 1; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (equiv != 0 && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te); - if (*ne) ++ne; - } - return equiv; +SWIGRUNTIME int SWIG_TypeCmp(const char* nb, const char* tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while ( equiv != 0 && *ne ) { + for ( nb = ne; *ne; ++ne ) { + if ( *ne == '|' ) + break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if ( *ne ) + ++ne; + } + return equiv; } /* Check type equivalence in a name list like ||... Return 0 if not equal, 1 if equal */ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; -} +SWIGRUNTIME int SWIG_TypeEquiv(const char* nb, const char* tb) { return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; } /* Check the typename */ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; +SWIGRUNTIME swig_cast_info* SWIG_TypeCheck(const char* c, swig_type_info* ty) { + if ( ty ) { + swig_cast_info* iter = ty->cast; + while ( iter ) { + if ( strcmp(iter->type->name, c) == 0 ) { + if ( iter == ty->cast ) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if ( iter->next ) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if ( ty->cast ) + ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } } - } - return 0; + return 0; } /* Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison */ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; +SWIGRUNTIME swig_cast_info* SWIG_TypeCheckStruct(swig_type_info* from, swig_type_info* ty) { + if ( ty ) { + swig_cast_info* iter = ty->cast; + while ( iter ) { + if ( iter->type == from ) { + if ( iter == ty->cast ) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if ( iter->next ) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if ( ty->cast ) + ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } } - } - return 0; + return 0; } /* Cast a pointer up an inheritance hierarchy */ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +SWIGRUNTIMEINLINE void* SWIG_TypeCast(swig_cast_info* ty, void* ptr, int* newmemory) { + return ((! ty) || (! ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); } /* Dynamic pointer casting. Down an inheritance hierarchy */ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; +SWIGRUNTIME swig_type_info* SWIG_TypeDynamicCast(swig_type_info* ty, void** ptr) { + swig_type_info* lastty = ty; + if ( ! ty || ! ty->dcast ) + return ty; + while ( ty && (ty->dcast) ) { + ty = (*ty->dcast)(ptr); + if ( ty ) + lastty = ty; + } + return lastty; } /* Return the name associated with this type */ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} +SWIGRUNTIMEINLINE const char* SWIG_TypeName(const swig_type_info* ty) { return ty->name; } /* Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (!type) return NULL; - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; +SWIGRUNTIME const char* SWIG_TypePrettyName(const swig_type_info* type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if ( ! type ) + return NULL; + if ( type->str != NULL ) { + const char* last_name = type->str; + const char* s; + for ( s = type->str; *s; s++ ) + if ( *s == '|' ) + last_name = s + 1; + return last_name; + } + else + return type->name; } /* Set the clientdata field for a type */ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } +SWIGRUNTIME void SWIG_TypeClientData(swig_type_info* ti, void* clientdata) { + swig_cast_info* cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while ( cast ) { + if ( ! cast->converter ) { + swig_type_info* tc = cast->type; + if ( ! tc->clientdata ) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; } - cast = cast->next; - } } -SWIGRUNTIME void -SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { - SWIG_TypeClientData(ti, clientdata); - ti->owndata = 1; +SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info* ti, void* clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; } /* @@ -572,40 +579,42 @@ SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { Note: if start == end at the beginning of the function, we go all the way around the circular list. */ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - size_t l = 0; - size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; +SWIGRUNTIME swig_type_info* SWIG_MangledTypeQueryModule(swig_module_info* start, swig_module_info* end, + const char* name) { + swig_module_info* iter = start; + do { + if ( iter->size ) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char* iname = iter->types[i]->name; + if ( iname ) { + int compare = strcmp(name, iname); + if ( compare == 0 ) { + return iter->types[i]; + } + else if ( compare < 0 ) { + if ( i ) { + r = i - 1; + } + else { + break; + } + } + else if ( compare > 0 ) { + l = i + 1; + } + } + else { + break; /* should never happen */ + } + } while ( l <= r ); + } + iter = iter->next; + } while ( iter != end ); + return 0; } /* @@ -617,129 +626,127 @@ SWIG_MangledTypeQueryModule(swig_module_info *start, Note: if start == end at the beginning of the function, we go all the way around the circular list. */ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } +SWIGRUNTIME swig_type_info* SWIG_TypeQueryModule(swig_module_info* start, swig_module_info* end, const char* name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info* ret = SWIG_MangledTypeQueryModule(start, end, name); + if ( ret ) { + return ret; + } + else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info* iter = start; + do { + size_t i = 0; + for ( ; i < iter->size; ++i ) { + if ( iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)) ) + return iter->types[i]; + } + iter = iter->next; + } while ( iter != end ); + } - /* neither found a match */ - return 0; + /* neither found a match */ + return 0; } /* Pack binary data into a string */ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - const unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; +SWIGRUNTIME char* SWIG_PackData(char* c, void* ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char* u = (unsigned char*)ptr; + const unsigned char* eu = u + sz; + for ( ; u != eu; ++u ) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; } /* Unpack binary data from a string */ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - char d = *(c++); - unsigned char uu; - if ((d >= '0') && (d <= '9')) - uu = (unsigned char)((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = (unsigned char)((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (unsigned char)(d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (unsigned char)(d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; +SWIGRUNTIME const char* SWIG_UnpackData(const char* c, void* ptr, size_t sz) { + unsigned char* u = (unsigned char*)ptr; + const unsigned char* eu = u + sz; + for ( ; u != eu; ++u ) { + char d = *(c++); + unsigned char uu; + if ( (d >= '0') && (d <= '9') ) + uu = (unsigned char)((d - '0') << 4); + else if ( (d >= 'a') && (d <= 'f') ) + uu = (unsigned char)((d - ('a' - 10)) << 4); + else + return (char*)0; + d = *(c++); + if ( (d >= '0') && (d <= '9') ) + uu |= (unsigned char)(d - '0'); + else if ( (d >= 'a') && (d <= 'f') ) + uu |= (unsigned char)(d - ('a' - 10)); + else + return (char*)0; + *u = uu; + } + return c; } /* Pack 'void *' into a string buffer. */ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; +SWIGRUNTIME char* SWIG_PackVoidPtr(char* buff, void* ptr, const char* name, size_t bsz) { + char* r = buff; + if ( (2 * sizeof(void*) + 2) > bsz ) + return 0; + *(r++) = '_'; + r = SWIG_PackData(r, &ptr, sizeof(void*)); + if ( strlen(name) + 1 > (bsz - (r - buff)) ) + return 0; + strcpy(r, name); + return buff; +} + +SWIGRUNTIME const char* SWIG_UnpackVoidPtr(const char* c, void** ptr, const char* name) { + if ( *c != '_' ) { + if ( strcmp(c, "NULL") == 0 ) { + *ptr = (void*)0; + return name; + } + else { + return 0; + } } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; + return SWIG_UnpackData(++c, ptr, sizeof(void*)); +} + +SWIGRUNTIME char* SWIG_PackDataName(char* buff, void* ptr, size_t sz, const char* name, size_t bsz) { + char* r = buff; + size_t lname = (name ? strlen(name) : 0); + if ( (2 * sz + 2 + lname) > bsz ) + return 0; + *(r++) = '_'; + r = SWIG_PackData(r, ptr, sz); + if ( lname ) { + strncpy(r, name, lname + 1); + } + else { + *r = 0; + } + return buff; } -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; +SWIGRUNTIME const char* SWIG_UnpackDataName(const char* c, void* ptr, size_t sz, const char* name) { + if ( *c != '_' ) { + if ( strcmp(c, "NULL") == 0 ) { + memset(ptr, 0, sz); + return name; + } + else { + return 0; + } } - } - return SWIG_UnpackData(++c,ptr,sz); + return SWIG_UnpackData(++c, ptr, sz); } #ifdef __cplusplus @@ -747,33 +754,32 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #endif /* Errors in SWIG */ -#define SWIG_UnknownError -1 -#define SWIG_IOError -2 -#define SWIG_RuntimeError -3 -#define SWIG_IndexError -4 -#define SWIG_TypeError -5 -#define SWIG_DivisionByZero -6 -#define SWIG_OverflowError -7 -#define SWIG_SyntaxError -8 -#define SWIG_ValueError -9 -#define SWIG_SystemError -10 -#define SWIG_AttributeError -11 -#define SWIG_MemoryError -12 -#define SWIG_NullReferenceError -13 - +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 /* Compatibility macros for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 -#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject*)&PyType_Type) #define PyInt_Check(x) PyLong_Check(x) #define PyInt_AsLong(x) PyLong_AsLong(x) #define PyInt_FromLong(x) PyLong_FromLong(x) #define PyInt_FromSize_t(x) PyLong_FromSize_t(x) #define PyString_Check(name) PyBytes_Check(name) #define PyString_FromString(x) PyUnicode_FromString(x) -#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) #define PyString_AsString(str) PyBytes_AsString(str) #define PyString_Size(str) PyBytes_Size(str) #define PyString_InternFromString(key) PyUnicode_InternFromString(key) @@ -784,137 +790,134 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { #endif #ifndef Py_TYPE -# define Py_TYPE(op) ((op)->ob_type) +#define Py_TYPE(op) ((op)->ob_type) #endif /* SWIG APIs for compatibility of both Python 2 & 3 */ #if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#define SWIG_Python_str_FromFormat PyUnicode_FromFormat #else -# define SWIG_Python_str_FromFormat PyString_FromFormat +#define SWIG_Python_str_FromFormat PyString_FromFormat #endif /* Warning: This function will allocate a new string in Python 3, * so please call SWIG_Python_str_DelForPy3(x) to free the space. */ -SWIGINTERN char* -SWIG_Python_str_AsChar(PyObject *str) -{ +SWIGINTERN char* SWIG_Python_str_AsChar(PyObject* str) { #if PY_VERSION_HEX >= 0x03000000 - char *cstr; - char *newstr; - Py_ssize_t len; - str = PyUnicode_AsUTF8String(str); - PyBytes_AsStringAndSize(str, &cstr, &len); - newstr = (char *) malloc(len+1); - memcpy(newstr, cstr, len+1); - Py_XDECREF(str); - return newstr; + char* cstr; + char* newstr; + Py_ssize_t len; + str = PyUnicode_AsUTF8String(str); + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char*)malloc(len + 1); + memcpy(newstr, cstr, len + 1); + Py_XDECREF(str); + return newstr; #else - return PyString_AsString(str); + return PyString_AsString(str); #endif } #if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#define SWIG_Python_str_DelForPy3(x) free((void*)(x)) #else -# define SWIG_Python_str_DelForPy3(x) +#define SWIG_Python_str_DelForPy3(x) #endif -SWIGINTERN PyObject* -SWIG_Python_str_FromChar(const char *c) -{ +SWIGINTERN PyObject* SWIG_Python_str_FromChar(const char* c) { #if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_FromString(c); + return PyUnicode_FromString(c); #else - return PyString_FromString(c); + return PyString_FromString(c); #endif } /* Add PyOS_snprintf for old Pythons */ #if PY_VERSION_HEX < 0x02020000 -# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) -# define PyOS_snprintf _snprintf -# else -# define PyOS_snprintf snprintf -# endif +#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +#define PyOS_snprintf _snprintf +#else +#define PyOS_snprintf snprintf +#endif #endif /* A crude PyString_FromFormat implementation for old Pythons */ #if PY_VERSION_HEX < 0x02020000 #ifndef SWIG_PYBUFFER_SIZE -# define SWIG_PYBUFFER_SIZE 1024 -#endif - -static PyObject * -PyString_FromFormat(const char *fmt, ...) { - va_list ap; - char buf[SWIG_PYBUFFER_SIZE * 2]; - int res; - va_start(ap, fmt); - res = vsnprintf(buf, sizeof(buf), fmt, ap); - va_end(ap); - return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); +#define SWIG_PYBUFFER_SIZE 1024 +#endif + +static PyObject* PyString_FromFormat(const char* fmt, ...) { + va_list ap; + char buf[SWIG_PYBUFFER_SIZE * 2]; + int res; + va_start(ap, fmt); + res = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); } #endif #ifndef PyObject_DEL -# define PyObject_DEL PyObject_Del +#define PyObject_DEL PyObject_Del #endif /* A crude PyExc_StopIteration exception for old Pythons */ #if PY_VERSION_HEX < 0x02020000 -# ifndef PyExc_StopIteration -# define PyExc_StopIteration PyExc_RuntimeError -# endif -# ifndef PyObject_GenericGetAttr -# define PyObject_GenericGetAttr 0 -# endif +#ifndef PyExc_StopIteration +#define PyExc_StopIteration PyExc_RuntimeError +#endif +#ifndef PyObject_GenericGetAttr +#define PyObject_GenericGetAttr 0 +#endif #endif /* Py_NotImplemented is defined in 2.1 and up. */ #if PY_VERSION_HEX < 0x02010000 -# ifndef Py_NotImplemented -# define Py_NotImplemented PyExc_RuntimeError -# endif +#ifndef Py_NotImplemented +#define Py_NotImplemented PyExc_RuntimeError +#endif #endif /* A crude PyString_AsStringAndSize implementation for old Pythons */ #if PY_VERSION_HEX < 0x02010000 -# ifndef PyString_AsStringAndSize -# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} -# endif +#ifndef PyString_AsStringAndSize +#define PyString_AsStringAndSize(obj, s, len) \ + { \ + *s = PyString_AsString(obj); \ + *len = *s ? strlen(*s) : 0; \ + } +#endif #endif /* PySequence_Size for old Pythons */ #if PY_VERSION_HEX < 0x02000000 -# ifndef PySequence_Size -# define PySequence_Size PySequence_Length -# endif +#ifndef PySequence_Size +#define PySequence_Size PySequence_Length +#endif #endif /* PyBool_FromLong for old Pythons */ #if PY_VERSION_HEX < 0x02030000 -static -PyObject *PyBool_FromLong(long ok) -{ - PyObject *result = ok ? Py_True : Py_False; - Py_INCREF(result); - return result; +static PyObject* PyBool_FromLong(long ok) { + PyObject* result = ok ? Py_True : Py_False; + Py_INCREF(result); + return result; } #endif /* Py_ssize_t for old Pythons */ /* This code is as recommended by: */ /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ -#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +#if PY_VERSION_HEX < 0x02050000 && ! defined(PY_SSIZE_T_MIN) typedef int Py_ssize_t; -# define PY_SSIZE_T_MAX INT_MAX -# define PY_SSIZE_T_MIN INT_MIN +#define PY_SSIZE_T_MAX INT_MAX +#define PY_SSIZE_T_MIN INT_MIN typedef inquiry lenfunc; typedef intargfunc ssizeargfunc; typedef intintargfunc ssizessizeargfunc; @@ -924,15 +927,14 @@ typedef getreadbufferproc readbufferproc; typedef getwritebufferproc writebufferproc; typedef getsegcountproc segcountproc; typedef getcharbufferproc charbufferproc; -static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) -{ - long result = 0; - PyObject *i = PyNumber_Int(x); - if (i) { - result = PyInt_AsLong(i); - Py_DECREF(i); - } - return result; +static long PyNumber_AsSsize_t(PyObject* x, void* SWIGUNUSEDPARM(exc)) { + long result = 0; + PyObject* i = PyNumber_Int(x); + if ( i ) { + result = PyInt_AsLong(i); + Py_DECREF(i); + } + return result; } #endif @@ -941,24 +943,24 @@ static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) #endif #if PY_VERSION_HEX < 0x02040000 -#define Py_VISIT(op) \ - do { \ - if (op) { \ - int vret = visit((op), arg); \ - if (vret) \ - return vret; \ - } \ - } while (0) +#define Py_VISIT(op) \ + do { \ + if ( op ) { \ + int vret = visit((op), arg); \ + if ( vret ) \ + return vret; \ + } \ + } while ( 0 ) #endif #if PY_VERSION_HEX < 0x02030000 typedef struct { - PyTypeObject type; - PyNumberMethods as_number; - PyMappingMethods as_mapping; - PySequenceMethods as_sequence; - PyBufferProcs as_buffer; - PyObject *name, *slots; + PyTypeObject type; + PyNumberMethods as_number; + PyMappingMethods as_mapping; + PySequenceMethods as_sequence; + PyBufferProcs as_buffer; + PyObject *name, *slots; } PyHeapTypeObject; #endif @@ -966,16 +968,16 @@ typedef struct { typedef destructor freefunc; #endif -#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ - (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ - (PY_MAJOR_VERSION > 3)) -# define SWIGPY_USE_CAPSULE -# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) +#if ( (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ + (PY_MAJOR_VERSION > 3) ) +#define SWIGPY_USE_CAPSULE +#define SWIGPY_CAPSULE_NAME \ + ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) #endif #if PY_VERSION_HEX < 0x03020000 -#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) -#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define PyDescr_TYPE(x) (((PyDescrObject*)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject*)(x))->d_name) #define Py_hash_t long #endif @@ -983,138 +985,126 @@ typedef destructor freefunc; * error manipulation * ----------------------------------------------------------------------------- */ -SWIGRUNTIME PyObject* -SWIG_Python_ErrorType(int code) { - PyObject* type = 0; - switch(code) { - case SWIG_MemoryError: - type = PyExc_MemoryError; - break; - case SWIG_IOError: - type = PyExc_IOError; - break; - case SWIG_RuntimeError: - type = PyExc_RuntimeError; - break; - case SWIG_IndexError: - type = PyExc_IndexError; - break; - case SWIG_TypeError: - type = PyExc_TypeError; - break; - case SWIG_DivisionByZero: - type = PyExc_ZeroDivisionError; - break; - case SWIG_OverflowError: - type = PyExc_OverflowError; - break; - case SWIG_SyntaxError: - type = PyExc_SyntaxError; - break; - case SWIG_ValueError: - type = PyExc_ValueError; - break; - case SWIG_SystemError: - type = PyExc_SystemError; - break; - case SWIG_AttributeError: - type = PyExc_AttributeError; - break; - default: - type = PyExc_RuntimeError; - } - return type; +SWIGRUNTIME PyObject* SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch ( code ) { + case SWIG_MemoryError: type = PyExc_MemoryError; break; + case SWIG_IOError: type = PyExc_IOError; break; + case SWIG_RuntimeError: type = PyExc_RuntimeError; break; + case SWIG_IndexError: type = PyExc_IndexError; break; + case SWIG_TypeError: type = PyExc_TypeError; break; + case SWIG_DivisionByZero: type = PyExc_ZeroDivisionError; break; + case SWIG_OverflowError: type = PyExc_OverflowError; break; + case SWIG_SyntaxError: type = PyExc_SyntaxError; break; + case SWIG_ValueError: type = PyExc_ValueError; break; + case SWIG_SystemError: type = PyExc_SystemError; break; + case SWIG_AttributeError: type = PyExc_AttributeError; break; + default: type = PyExc_RuntimeError; + } + return type; } -SWIGRUNTIME void -SWIG_Python_AddErrorMsg(const char* mesg) -{ - PyObject *type = 0; - PyObject *value = 0; - PyObject *traceback = 0; - - if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); - if (value) { - char *tmp; - PyObject *old_str = PyObject_Str(value); - PyErr_Clear(); - Py_XINCREF(type); - - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); - Py_DECREF(value); - } else { - PyErr_SetString(PyExc_RuntimeError, mesg); - } +SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char* mesg) { + PyObject* type = 0; + PyObject* value = 0; + PyObject* traceback = 0; + + if ( PyErr_Occurred() ) + PyErr_Fetch(&type, &value, &traceback); + if ( value ) { + char* tmp; + PyObject* old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); + + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } + else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } } #if defined(SWIG_PYTHON_NO_THREADS) -# if defined(SWIG_PYTHON_THREADS) -# undef SWIG_PYTHON_THREADS -# endif +#if defined(SWIG_PYTHON_THREADS) +#undef SWIG_PYTHON_THREADS +#endif #endif #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ -# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) -# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ -# define SWIG_PYTHON_USE_GIL -# endif -# endif -# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ -# ifndef SWIG_PYTHON_INITIALIZE_THREADS -# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() -# endif -# ifdef __cplusplus /* C++ code */ - class SWIG_Python_Thread_Block { - bool status; - PyGILState_STATE state; - public: - void end() { if (status) { PyGILState_Release(state); status = false;} } - SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} - ~SWIG_Python_Thread_Block() { end(); } - }; - class SWIG_Python_Thread_Allow { - bool status; - PyThreadState *save; - public: - void end() { if (status) { PyEval_RestoreThread(save); status = false; }} - SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} - ~SWIG_Python_Thread_Allow() { end(); } - }; -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block -# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow -# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() -# else /* C code */ -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() -# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() -# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) -# endif -# else /* Old thread way, not implemented, user must provide it */ -# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) -# define SWIG_PYTHON_INITIALIZE_THREADS -# endif -# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK -# endif -# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) -# define SWIG_PYTHON_THREAD_END_BLOCK -# endif -# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW -# endif -# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) -# define SWIG_PYTHON_THREAD_END_ALLOW -# endif -# endif +#if ! defined(SWIG_PYTHON_USE_GIL) && ! defined(SWIG_PYTHON_NO_USE_GIL) +#if ( PY_VERSION_HEX >= 0x02030000 ) /* For 2.3 or later, use the PyGILState calls */ +#define SWIG_PYTHON_USE_GIL +#endif +#endif +#if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +#ifndef SWIG_PYTHON_INITIALIZE_THREADS +#define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +#endif +#ifdef __cplusplus /* C++ code */ +class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + +public: + void end() { + if ( status ) { + PyGILState_Release(state); + status = false; + } + } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } +}; +class SWIG_Python_Thread_Allow { + bool status; + PyThreadState* save; + +public: + void end() { + if ( status ) { + PyEval_RestoreThread(save); + status = false; + } + } + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } +}; +#define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +#define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +#define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +#define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +#else /* C code */ +#define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +#define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +#define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState* _swig_thread_allow = PyEval_SaveThread() +#define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +#endif +#else /* Old thread way, not implemented, user must provide it */ +#if ! defined(SWIG_PYTHON_INITIALIZE_THREADS) +#define SWIG_PYTHON_INITIALIZE_THREADS +#endif +#if ! defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +#define SWIG_PYTHON_THREAD_BEGIN_BLOCK +#endif +#if ! defined(SWIG_PYTHON_THREAD_END_BLOCK) +#define SWIG_PYTHON_THREAD_END_BLOCK +#endif +#if ! defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +#define SWIG_PYTHON_THREAD_BEGIN_ALLOW +#endif +#if ! defined(SWIG_PYTHON_THREAD_END_ALLOW) +#define SWIG_PYTHON_THREAD_END_ALLOW +#endif +#endif #else /* No thread support */ -# define SWIG_PYTHON_INITIALIZE_THREADS -# define SWIG_PYTHON_THREAD_BEGIN_BLOCK -# define SWIG_PYTHON_THREAD_END_BLOCK -# define SWIG_PYTHON_THREAD_BEGIN_ALLOW -# define SWIG_PYTHON_THREAD_END_ALLOW +#define SWIG_PYTHON_INITIALIZE_THREADS +#define SWIG_PYTHON_THREAD_BEGIN_BLOCK +#define SWIG_PYTHON_THREAD_END_BLOCK +#define SWIG_PYTHON_THREAD_BEGIN_ALLOW +#define SWIG_PYTHON_THREAD_END_ALLOW #endif /* ----------------------------------------------------------------------------- @@ -1131,16 +1121,16 @@ extern "C" { /* Constant Types */ #define SWIG_PY_POINTER 4 -#define SWIG_PY_BINARY 5 +#define SWIG_PY_BINARY 5 /* Constant information structure */ typedef struct swig_const_info { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; + int type; + char* name; + long lvalue; + double dvalue; + void* pvalue; + swig_type_info** ptype; } swig_const_info; @@ -1149,14 +1139,12 @@ typedef struct swig_const_info { * It is exported to the generated module, used for -fastproxy * ----------------------------------------------------------------------------- */ #if PY_VERSION_HEX >= 0x03000000 -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) -{ - return PyInstanceMethod_New(func); +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject* SWIGUNUSEDPARM(self), PyObject* func) { + return PyInstanceMethod_New(func); } #else -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) -{ - return NULL; +SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject* SWIGUNUSEDPARM(self), PyObject* SWIGUNUSEDPARM(func)) { + return NULL; } #endif @@ -1177,208 +1165,209 @@ SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), /* Common SWIG API */ /* for raw pointers */ -#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) -#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) -#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj, pptr, type, flags, own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) #ifdef SWIGPYTHON_BUILTIN -#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) #else -#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) #endif -#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) -#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) -#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) -#define swig_owntype int +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int /* for raw packed data */ -#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) -#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* for class or struct pointers */ -#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) -#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) /* for C or C++ function pointers */ -#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) -#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) /* for C++ member pointers, ie, member methods */ -#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) -#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) /* Runtime API */ -#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) -#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) -#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) -#define SWIG_SetErrorObj SWIG_Python_SetErrorObj -#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg -#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) -#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) -#define SWIG_fail goto fail +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail /* Runtime API implementation */ /* Error manipulation */ -SWIGINTERN void -SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - PyErr_SetObject(errtype, obj); - Py_DECREF(obj); - SWIG_PYTHON_THREAD_END_BLOCK; +SWIGINTERN void SWIG_Python_SetErrorObj(PyObject* errtype, PyObject* obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; } -SWIGINTERN void -SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - PyErr_SetString(errtype, msg); - SWIG_PYTHON_THREAD_END_BLOCK; +SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject* errtype, const char* msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; } -#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) /* Set a constant value */ #if defined(SWIGPYTHON_BUILTIN) -SWIGINTERN void -SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { - PyObject *s = PyString_InternFromString(key); - PyList_Append(seq, s); - Py_DECREF(s); +SWIGINTERN void SwigPyBuiltin_AddPublicSymbol(PyObject* seq, const char* key) { + PyObject* s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); } -SWIGINTERN void -SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { +SWIGINTERN void SWIG_Python_SetConstant(PyObject* d, PyObject* public_interface, const char* name, PyObject* obj) { #if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); + PyDict_SetItemString(d, (char*)name, obj); #else - PyDict_SetItemString(d, name, obj); + PyDict_SetItemString(d, name, obj); #endif - Py_DECREF(obj); - if (public_interface) - SwigPyBuiltin_AddPublicSymbol(public_interface, name); + Py_DECREF(obj); + if ( public_interface ) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); } #else -SWIGINTERN void -SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { +SWIGINTERN void SWIG_Python_SetConstant(PyObject* d, const char* name, PyObject* obj) { #if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); + PyDict_SetItemString(d, (char*)name, obj); #else - PyDict_SetItemString(d, name, obj); + PyDict_SetItemString(d, name, obj); #endif - Py_DECREF(obj); + Py_DECREF(obj); } #endif /* Append a value to the result obj */ -SWIGINTERN PyObject* -SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { -#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) - if (!result) { - result = obj; - } else if (result == Py_None) { - Py_DECREF(result); - result = obj; - } else { - if (!PyList_Check(result)) { - PyObject *o2 = result; - result = PyList_New(1); - PyList_SetItem(result, 0, o2); - } - PyList_Append(result,obj); - Py_DECREF(obj); - } - return result; +SWIGINTERN PyObject* SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +#if ! defined(SWIG_PYTHON_OUTPUT_TUPLE) + if ( ! result ) { + result = obj; + } + else if ( result == Py_None ) { + Py_DECREF(result); + result = obj; + } + else { + if ( ! PyList_Check(result) ) { + PyObject* o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result, obj); + Py_DECREF(obj); + } + return result; #else - PyObject* o2; - PyObject* o3; - if (!result) { - result = obj; - } else if (result == Py_None) { - Py_DECREF(result); - result = obj; - } else { - if (!PyTuple_Check(result)) { - o2 = result; - result = PyTuple_New(1); - PyTuple_SET_ITEM(result, 0, o2); - } - o3 = PyTuple_New(1); - PyTuple_SET_ITEM(o3, 0, obj); - o2 = result; - result = PySequence_Concat(o2, o3); - Py_DECREF(o2); - Py_DECREF(o3); - } - return result; + PyObject* o2; + PyObject* o3; + if ( ! result ) { + result = obj; + } + else if ( result == Py_None ) { + Py_DECREF(result); + result = obj; + } + else { + if ( ! PyTuple_Check(result) ) { + o2 = result; + result = PyTuple_New(1); + PyTuple_SET_ITEM(result, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SET_ITEM(o3, 0, obj); + o2 = result; + result = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return result; #endif } /* Unpack the argument tuple */ -SWIGINTERN Py_ssize_t -SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) -{ - if (!args) { - if (!min && !max) { - return 1; - } else { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", - name, (min == max ? "" : "at least "), (int)min); - return 0; - } - } - if (!PyTuple_Check(args)) { - if (min <= 1 && max >= 1) { - Py_ssize_t i; - objs[0] = args; - for (i = 1; i < max; ++i) { - objs[i] = 0; - } - return 2; +SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject* args, const char* name, Py_ssize_t min, Py_ssize_t max, + PyObject** objs) { + if ( ! args ) { + if ( ! min && ! max ) { + return 1; + } + else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", name, (min == max ? "" : "at least "), + (int)min); + return 0; + } } - PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); - return 0; - } else { - Py_ssize_t l = PyTuple_GET_SIZE(args); - if (l < min) { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", - name, (min == max ? "" : "at least "), (int)min, (int)l); - return 0; - } else if (l > max) { - PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", - name, (min == max ? "" : "at most "), (int)max, (int)l); - return 0; - } else { - Py_ssize_t i; - for (i = 0; i < l; ++i) { - objs[i] = PyTuple_GET_ITEM(args, i); - } - for (; l < max; ++l) { - objs[l] = 0; - } - return i + 1; + if ( ! PyTuple_Check(args) ) { + if ( min <= 1 && max >= 1 ) { + Py_ssize_t i; + objs[0] = args; + for ( i = 1; i < max; ++i ) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } + else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if ( l < min ) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at least "), + (int)min, (int)l); + return 0; + } + else if ( l > max ) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", name, (min == max ? "" : "at most "), + (int)max, (int)l); + return 0; + } + else { + Py_ssize_t i; + for ( i = 0; i < l; ++i ) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for ( ; l < max; ++l ) { + objs[l] = 0; + } + return i + 1; + } } - } } /* A functor is a function object with one single object argument */ #if PY_VERSION_HEX >= 0x02020000 -#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); #else -#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); #endif /* @@ -1386,9 +1375,12 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); */ #ifdef __cplusplus -#define SWIG_STATIC_POINTER(var) var +#define SWIG_STATIC_POINTER(var) var #else -#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#define SWIG_STATIC_POINTER(var) \ + var = 0; \ + if ( ! var ) \ + var #endif /* ----------------------------------------------------------------------------- @@ -1396,13 +1388,13 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi * ----------------------------------------------------------------------------- */ /* Flags for new pointer objects */ -#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) -#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) -#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) -#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) -#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) #ifdef __cplusplus extern "C" { @@ -1410,623 +1402,648 @@ extern "C" { /* How to access Py_None */ #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# ifndef SWIG_PYTHON_NO_BUILD_NONE -# ifndef SWIG_PYTHON_BUILD_NONE -# define SWIG_PYTHON_BUILD_NONE -# endif -# endif +#ifndef SWIG_PYTHON_NO_BUILD_NONE +#ifndef SWIG_PYTHON_BUILD_NONE +#define SWIG_PYTHON_BUILD_NONE +#endif +#endif #endif #ifdef SWIG_PYTHON_BUILD_NONE -# ifdef Py_None -# undef Py_None -# define Py_None SWIG_Py_None() -# endif -SWIGRUNTIMEINLINE PyObject * -_SWIG_Py_None(void) -{ - PyObject *none = Py_BuildValue((char*)""); - Py_DECREF(none); - return none; +#ifdef Py_None +#undef Py_None +#define Py_None SWIG_Py_None() +#endif +SWIGRUNTIMEINLINE PyObject* _SWIG_Py_None(void) { + PyObject* none = Py_BuildValue((char*)""); + Py_DECREF(none); + return none; } -SWIGRUNTIME PyObject * -SWIG_Py_None(void) -{ - static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); - return none; +SWIGRUNTIME PyObject* SWIG_Py_None(void) { + static PyObject* SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); + return none; } #endif /* The python void return value */ -SWIGRUNTIMEINLINE PyObject * -SWIG_Py_Void(void) -{ - PyObject *none = Py_None; - Py_INCREF(none); - return none; +SWIGRUNTIMEINLINE PyObject* SWIG_Py_Void(void) { + PyObject* none = Py_None; + Py_INCREF(none); + return none; } /* SwigPyClientData */ typedef struct { - PyObject *klass; - PyObject *newraw; - PyObject *newargs; - PyObject *destroy; - int delargs; - int implicitconv; - PyTypeObject *pytype; + PyObject* klass; + PyObject* newraw; + PyObject* newargs; + PyObject* destroy; + int delargs; + int implicitconv; + PyTypeObject* pytype; } SwigPyClientData; -SWIGRUNTIMEINLINE int -SWIG_Python_CheckImplicit(swig_type_info *ty) -{ - SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; - return data ? data->implicitconv : 0; +SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info* ty) { + SwigPyClientData* data = (SwigPyClientData*)ty->clientdata; + return data ? data->implicitconv : 0; } -SWIGRUNTIMEINLINE PyObject * -SWIG_Python_ExceptionType(swig_type_info *desc) { - SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; - PyObject *klass = data ? data->klass : 0; - return (klass ? klass : PyExc_RuntimeError); +SWIGRUNTIMEINLINE PyObject* SWIG_Python_ExceptionType(swig_type_info* desc) { + SwigPyClientData* data = desc ? (SwigPyClientData*)desc->clientdata : 0; + PyObject* klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); } -SWIGRUNTIME SwigPyClientData * -SwigPyClientData_New(PyObject* obj) -{ - if (!obj) { - return 0; - } else { - SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); - /* the klass element */ - data->klass = obj; - Py_INCREF(data->klass); - /* the newraw method and newargs arguments used to create a new raw instance */ - if (PyClass_Check(obj)) { - data->newraw = 0; - data->newargs = obj; - Py_INCREF(obj); - } else { -#if (PY_VERSION_HEX < 0x02020000) - data->newraw = 0; +SWIGRUNTIME SwigPyClientData* SwigPyClientData_New(PyObject* obj) { + if ( ! obj ) { + return 0; + } + else { + SwigPyClientData* data = (SwigPyClientData*)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if ( PyClass_Check(obj) ) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } + else { +#if ( PY_VERSION_HEX < 0x02020000 ) + data->newraw = 0; #else - data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); + data->newraw = PyObject_GetAttrString(data->klass, (char*)"__new__"); #endif - if (data->newraw) { - Py_INCREF(data->newraw); - data->newargs = PyTuple_New(1); - PyTuple_SetItem(data->newargs, 0, obj); - } else { - data->newargs = obj; - } - Py_INCREF(data->newargs); - } - /* the destroy method, aka as the C++ delete method */ - data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); - if (PyErr_Occurred()) { - PyErr_Clear(); - data->destroy = 0; - } - if (data->destroy) { - int flags; - Py_INCREF(data->destroy); - flags = PyCFunction_GET_FLAGS(data->destroy); + if ( data->newraw ) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } + else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, (char*)"__swig_destroy__"); + if ( PyErr_Occurred() ) { + PyErr_Clear(); + data->destroy = 0; + } + if ( data->destroy ) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); #ifdef METH_O - data->delargs = !(flags & (METH_O)); + data->delargs = ! (flags & (METH_O)); #else - data->delargs = 0; + data->delargs = 0; #endif - } else { - data->delargs = 0; + } + else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; } - data->implicitconv = 0; - data->pytype = 0; - return data; - } } -SWIGRUNTIME void -SwigPyClientData_Del(SwigPyClientData *data) { - Py_XDECREF(data->newraw); - Py_XDECREF(data->newargs); - Py_XDECREF(data->destroy); +SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData* data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); } /* =============== SwigPyObject =====================*/ typedef struct { - PyObject_HEAD - void *ptr; - swig_type_info *ty; - int own; - PyObject *next; + PyObject_HEAD void* ptr; + swig_type_info* ty; + int own; + PyObject* next; #ifdef SWIGPYTHON_BUILTIN - PyObject *dict; + PyObject* dict; #endif } SwigPyObject; #ifdef SWIGPYTHON_BUILTIN -SWIGRUNTIME PyObject * -SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) -{ - SwigPyObject *sobj = (SwigPyObject *)v; +SWIGRUNTIME PyObject* SwigPyObject_get___dict__(PyObject* v, PyObject* SWIGUNUSEDPARM(args)) { + SwigPyObject* sobj = (SwigPyObject*)v; - if (!sobj->dict) - sobj->dict = PyDict_New(); + if ( ! sobj->dict ) + sobj->dict = PyDict_New(); - Py_INCREF(sobj->dict); - return sobj->dict; + Py_INCREF(sobj->dict); + return sobj->dict; } #endif -SWIGRUNTIME PyObject * -SwigPyObject_long(SwigPyObject *v) -{ - return PyLong_FromVoidPtr(v->ptr); -} +SWIGRUNTIME PyObject* SwigPyObject_long(SwigPyObject* v) { return PyLong_FromVoidPtr(v->ptr); } -SWIGRUNTIME PyObject * -SwigPyObject_format(const char* fmt, SwigPyObject *v) -{ - PyObject *res = NULL; - PyObject *args = PyTuple_New(1); - if (args) { - if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { - PyObject *ofmt = SWIG_Python_str_FromChar(fmt); - if (ofmt) { +SWIGRUNTIME PyObject* SwigPyObject_format(const char* fmt, SwigPyObject* v) { + PyObject* res = NULL; + PyObject* args = PyTuple_New(1); + if ( args ) { + if ( PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0 ) { + PyObject* ofmt = SWIG_Python_str_FromChar(fmt); + if ( ofmt ) { #if PY_VERSION_HEX >= 0x03000000 - res = PyUnicode_Format(ofmt,args); + res = PyUnicode_Format(ofmt, args); #else - res = PyString_Format(ofmt,args); + res = PyString_Format(ofmt, args); #endif - Py_DECREF(ofmt); - } - Py_DECREF(args); + Py_DECREF(ofmt); + } + Py_DECREF(args); + } } - } - return res; + return res; } -SWIGRUNTIME PyObject * -SwigPyObject_oct(SwigPyObject *v) -{ - return SwigPyObject_format("%o",v); -} +SWIGRUNTIME PyObject* SwigPyObject_oct(SwigPyObject* v) { return SwigPyObject_format("%o", v); } -SWIGRUNTIME PyObject * -SwigPyObject_hex(SwigPyObject *v) -{ - return SwigPyObject_format("%x",v); -} +SWIGRUNTIME PyObject* SwigPyObject_hex(SwigPyObject* v) { return SwigPyObject_format("%x", v); } -SWIGRUNTIME PyObject * +SWIGRUNTIME PyObject* #ifdef METH_NOARGS -SwigPyObject_repr(SwigPyObject *v) +SwigPyObject_repr(SwigPyObject* v) #else -SwigPyObject_repr(SwigPyObject *v, PyObject *args) +SwigPyObject_repr(SwigPyObject* v, PyObject* args) #endif { - const char *name = SWIG_TypePrettyName(v->ty); - PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); - if (v->next) { -# ifdef METH_NOARGS - PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); -# else - PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); -# endif -# if PY_VERSION_HEX >= 0x03000000 - PyObject *joined = PyUnicode_Concat(repr, nrep); - Py_DecRef(repr); - Py_DecRef(nrep); - repr = joined; -# else - PyString_ConcatAndDel(&repr,nrep); -# endif - } - return repr; + const char* name = SWIG_TypePrettyName(v->ty); + PyObject* repr = + SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void*)v); + if ( v->next ) { +#ifdef METH_NOARGS + PyObject* nrep = SwigPyObject_repr((SwigPyObject*)v->next); +#else + PyObject* nrep = SwigPyObject_repr((SwigPyObject*)v->next, args); +#endif +#if PY_VERSION_HEX >= 0x03000000 + PyObject* joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +#else + PyString_ConcatAndDel(&repr, nrep); +#endif + } + return repr; } -SWIGRUNTIME int -SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) -{ - void *i = v->ptr; - void *j = w->ptr; - return (i < j) ? -1 : ((i > j) ? 1 : 0); +SWIGRUNTIME int SwigPyObject_compare(SwigPyObject* v, SwigPyObject* w) { + void* i = v->ptr; + void* j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); } /* Added for Python 3.x, would it also be useful for Python 2.x? */ -SWIGRUNTIME PyObject* -SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) -{ - PyObject* res; - if( op != Py_EQ && op != Py_NE ) { - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; - } - res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); - return res; +SWIGRUNTIME PyObject* SwigPyObject_richcompare(SwigPyObject* v, SwigPyObject* w, int op) { + PyObject* res; + if ( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong((SwigPyObject_compare(v, w) == 0) == (op == Py_EQ) ? 1 : 0); + return res; } SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); #ifdef SWIGPYTHON_BUILTIN -static swig_type_info *SwigPyObject_stype = 0; -SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { - SwigPyClientData *cd; +static swig_type_info* SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* SwigPyObject_type(void) { + SwigPyClientData* cd; assert(SwigPyObject_stype); - cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + cd = (SwigPyClientData*)SwigPyObject_stype->clientdata; assert(cd); assert(cd->pytype); return cd->pytype; } #else -SWIGRUNTIME PyTypeObject* -SwigPyObject_type(void) { - static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); - return type; +SWIGRUNTIME PyTypeObject* SwigPyObject_type(void) { + static PyTypeObject* SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; } #endif -SWIGRUNTIMEINLINE int -SwigPyObject_Check(PyObject *op) { +SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject* op) { #ifdef SWIGPYTHON_BUILTIN - PyTypeObject *target_tp = SwigPyObject_type(); - if (PyType_IsSubtype(op->ob_type, target_tp)) - return 1; - return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); + PyTypeObject* target_tp = SwigPyObject_type(); + if ( PyType_IsSubtype(op->ob_type, target_tp) ) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); #else - return (Py_TYPE(op) == SwigPyObject_type()) - || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); -#endif -} - -SWIGRUNTIME PyObject * -SwigPyObject_New(void *ptr, swig_type_info *ty, int own); - -SWIGRUNTIME void -SwigPyObject_dealloc(PyObject *v) -{ - SwigPyObject *sobj = (SwigPyObject *) v; - PyObject *next = sobj->next; - if (sobj->own == SWIG_POINTER_OWN) { - swig_type_info *ty = sobj->ty; - SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; - PyObject *destroy = data ? data->destroy : 0; - if (destroy) { - /* destroy is always a VARARGS method */ - PyObject *res; - - /* PyObject_CallFunction() has the potential to silently drop - the active active exception. In cases of unnamed temporary - variable or where we just finished iterating over a generator - StopIteration will be active right now, and this needs to - remain true upon return from SwigPyObject_dealloc. So save - and restore. */ - - PyObject *val = NULL, *type = NULL, *tb = NULL; - PyErr_Fetch(&val, &type, &tb); - - if (data->delargs) { - /* we need to create a temporary object to carry the destroy operation */ - PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); - res = SWIG_Python_CallFunctor(destroy, tmp); - Py_DECREF(tmp); - } else { - PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); - PyObject *mself = PyCFunction_GET_SELF(destroy); - res = ((*meth)(mself, v)); - } - if (!res) - PyErr_WriteUnraisable(destroy); + return (Py_TYPE(op) == SwigPyObject_type()) || (strcmp(Py_TYPE(op)->tp_name, "SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject* SwigPyObject_New(void* ptr, swig_type_info* ty, int own); + +SWIGRUNTIME void SwigPyObject_dealloc(PyObject* v) { + SwigPyObject* sobj = (SwigPyObject*)v; + PyObject* next = sobj->next; + if ( sobj->own == SWIG_POINTER_OWN ) { + swig_type_info* ty = sobj->ty; + SwigPyClientData* data = ty ? (SwigPyClientData*)ty->clientdata : 0; + PyObject* destroy = data ? data->destroy : 0; + if ( destroy ) { + /* destroy is always a VARARGS method */ + PyObject* res; + + /* PyObject_CallFunction() has the potential to silently drop + the active active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *val = NULL, *type = NULL, *tb = NULL; + PyErr_Fetch(&val, &type, &tb); + + if ( data->delargs ) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject* tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } + else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject* mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if ( ! res ) + PyErr_WriteUnraisable(destroy); - PyErr_Restore(val, type, tb); + PyErr_Restore(val, type, tb); - Py_XDECREF(res); - } -#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) - else { - const char *name = SWIG_TypePrettyName(ty); - printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); - } + Py_XDECREF(res); + } +#if ! defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char* name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", + (name ? name : "unknown")); + } #endif - } - Py_XDECREF(next); - PyObject_DEL(v); + } + Py_XDECREF(next); + PyObject_DEL(v); } -SWIGRUNTIME PyObject* -SwigPyObject_append(PyObject* v, PyObject* next) -{ - SwigPyObject *sobj = (SwigPyObject *) v; +SWIGRUNTIME PyObject* SwigPyObject_append(PyObject* v, PyObject* next) { + SwigPyObject* sobj = (SwigPyObject*)v; #ifndef METH_O - PyObject *tmp = 0; - if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; - next = tmp; -#endif - if (!SwigPyObject_Check(next)) { - PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); - return NULL; - } - sobj->next = next; - Py_INCREF(next); - return SWIG_Py_Void(); + PyObject* tmp = 0; + if ( ! PyArg_ParseTuple(next, (char*)"O:append", &tmp) ) + return NULL; + next = tmp; +#endif + if ( ! SwigPyObject_Check(next) ) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); } SWIGRUNTIME PyObject* #ifdef METH_NOARGS SwigPyObject_next(PyObject* v) #else -SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +SwigPyObject_next(PyObject* v, PyObject* SWIGUNUSEDPARM(args)) #endif { - SwigPyObject *sobj = (SwigPyObject *) v; - if (sobj->next) { - Py_INCREF(sobj->next); - return sobj->next; - } else { - return SWIG_Py_Void(); - } + SwigPyObject* sobj = (SwigPyObject*)v; + if ( sobj->next ) { + Py_INCREF(sobj->next); + return sobj->next; + } + else { + return SWIG_Py_Void(); + } } SWIGINTERN PyObject* #ifdef METH_NOARGS -SwigPyObject_disown(PyObject *v) +SwigPyObject_disown(PyObject* v) #else -SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +SwigPyObject_disown(PyObject* v, PyObject* SWIGUNUSEDPARM(args)) #endif { - SwigPyObject *sobj = (SwigPyObject *)v; - sobj->own = 0; - return SWIG_Py_Void(); + SwigPyObject* sobj = (SwigPyObject*)v; + sobj->own = 0; + return SWIG_Py_Void(); } SWIGINTERN PyObject* #ifdef METH_NOARGS -SwigPyObject_acquire(PyObject *v) +SwigPyObject_acquire(PyObject* v) #else -SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +SwigPyObject_acquire(PyObject* v, PyObject* SWIGUNUSEDPARM(args)) #endif { - SwigPyObject *sobj = (SwigPyObject *)v; - sobj->own = SWIG_POINTER_OWN; - return SWIG_Py_Void(); + SwigPyObject* sobj = (SwigPyObject*)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); } -SWIGINTERN PyObject* -SwigPyObject_own(PyObject *v, PyObject *args) -{ - PyObject *val = 0; -#if (PY_VERSION_HEX < 0x02020000) - if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +SWIGINTERN PyObject* SwigPyObject_own(PyObject* v, PyObject* args) { + PyObject* val = 0; +#if ( PY_VERSION_HEX < 0x02020000 ) + if ( ! PyArg_ParseTuple(args, (char*)"|O:own", &val) ) #elif (PY_VERSION_HEX < 0x02050000) - if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) + if ( ! PyArg_UnpackTuple(args, (char*)"own", 0, 1, &val) ) #else - if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) + if ( ! PyArg_UnpackTuple(args, "own", 0, 1, &val) ) #endif { - return NULL; + return NULL; } - else - { - SwigPyObject *sobj = (SwigPyObject *)v; - PyObject *obj = PyBool_FromLong(sobj->own); - if (val) { + else { + SwigPyObject* sobj = (SwigPyObject*)v; + PyObject* obj = PyBool_FromLong(sobj->own); + if ( val ) { #ifdef METH_NOARGS - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v); - } else { - SwigPyObject_disown(v); - } + if ( PyObject_IsTrue(val) ) { + SwigPyObject_acquire(v); + } + else { + SwigPyObject_disown(v); + } #else - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); - } else { - SwigPyObject_disown(v,args); - } + if ( PyObject_IsTrue(val) ) { + SwigPyObject_acquire(v, args); + } + else { + SwigPyObject_disown(v, args); + } #endif - } - return obj; + } + return obj; } } #ifdef METH_O -static PyMethodDef -swigobject_methods[] = { - {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"}, - {0, 0, 0, 0} -}; +static PyMethodDef swigobject_methods[] = + {{(char*)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char*)"releases ownership of the pointer"}, + {(char*)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char*)"acquires ownership of the pointer"}, + {(char*)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char*)"returns/sets ownership of the pointer"}, + {(char*)"append", (PyCFunction)SwigPyObject_append, METH_O, (char*)"appends another 'this' object"}, + {(char*)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char*)"returns the next 'this' object"}, + {(char*)"__repr__", (PyCFunction)SwigPyObject_repr, METH_NOARGS, (char*)"returns object representation"}, + {0, 0, 0, 0}}; #else -static PyMethodDef -swigobject_methods[] = { - {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, - {0, 0, 0, 0} -}; +static PyMethodDef swigobject_methods[] = + {{(char*)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char*)"releases ownership of the pointer"}, + {(char*)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char*)"acquires ownership of the pointer"}, + {(char*)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char*)"returns/sets ownership of the pointer"}, + {(char*)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char*)"appends another 'this' object"}, + {(char*)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char*)"returns the next 'this' object"}, + {(char*)"__repr__", (PyCFunction)SwigPyObject_repr, METH_VARARGS, (char*)"returns object representation"}, + {0, 0, 0, 0}}; #endif #if PY_VERSION_HEX < 0x02020000 -SWIGINTERN PyObject * -SwigPyObject_getattr(SwigPyObject *sobj,char *name) -{ - return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +SWIGINTERN PyObject* SwigPyObject_getattr(SwigPyObject* sobj, char* name) { + return Py_FindMethod(swigobject_methods, (PyObject*)sobj, name); } #endif -SWIGRUNTIME PyTypeObject* -SwigPyObject_TypeOnce(void) { - static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; - static PyNumberMethods SwigPyObject_as_number = { - (binaryfunc)0, /*nb_add*/ - (binaryfunc)0, /*nb_subtract*/ - (binaryfunc)0, /*nb_multiply*/ + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ /* nb_divide removed in Python 3 */ #if PY_VERSION_HEX < 0x03000000 - (binaryfunc)0, /*nb_divide*/ -#endif - (binaryfunc)0, /*nb_remainder*/ - (binaryfunc)0, /*nb_divmod*/ - (ternaryfunc)0,/*nb_power*/ - (unaryfunc)0, /*nb_negative*/ - (unaryfunc)0, /*nb_positive*/ - (unaryfunc)0, /*nb_absolute*/ - (inquiry)0, /*nb_nonzero*/ - 0, /*nb_invert*/ - 0, /*nb_lshift*/ - 0, /*nb_rshift*/ - 0, /*nb_and*/ - 0, /*nb_xor*/ - 0, /*nb_or*/ + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0, /*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ #if PY_VERSION_HEX < 0x03000000 - 0, /*nb_coerce*/ + 0, /*nb_coerce*/ #endif - (unaryfunc)SwigPyObject_long, /*nb_int*/ + (unaryfunc)SwigPyObject_long, /*nb_int*/ #if PY_VERSION_HEX < 0x03000000 - (unaryfunc)SwigPyObject_long, /*nb_long*/ + (unaryfunc)SwigPyObject_long, /*nb_long*/ #else - 0, /*nb_reserved*/ + 0, /*nb_reserved*/ #endif - (unaryfunc)0, /*nb_float*/ + (unaryfunc)0, /*nb_float*/ #if PY_VERSION_HEX < 0x03000000 - (unaryfunc)SwigPyObject_oct, /*nb_oct*/ - (unaryfunc)SwigPyObject_hex, /*nb_hex*/ + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ #endif #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 /* nb_inplace_add -> nb_index */ #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 /* nb_inplace_add -> nb_inplace_true_divide */ #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ - 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 /* nb_inplace_add -> nb_inplace_or */ #endif - }; + }; - static PyTypeObject swigpyobject_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if ( ! type_init ) { + const PyTypeObject tmp = { #if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) + PyVarObject_HEAD_INIT(NULL, 0) #else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ + PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - (char *)"SwigPyObject", /* tp_name */ - sizeof(SwigPyObject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor)SwigPyObject_dealloc, /* tp_dealloc */ - 0, /* tp_print */ + (char*) "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ #if PY_VERSION_HEX < 0x02020000 - (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ + (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ #else - (getattrfunc)0, /* tp_getattr */ + (getattrfunc)0, /* tp_getattr */ #endif - (setattrfunc)0, /* tp_setattr */ + (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX >= 0x03000000 - 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ #else - (cmpfunc)SwigPyObject_compare, /* tp_compare */ -#endif - (reprfunc)SwigPyObject_repr, /* tp_repr */ - &SwigPyObject_as_number, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - (hashfunc)0, /* tp_hash */ - (ternaryfunc)0, /* tp_call */ - 0, /* tp_str */ - PyObject_GenericGetAttr, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigobject_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ - 0, /* tp_weaklistoffset */ + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 - 0, /* tp_iter */ - 0, /* tp_iternext */ - swigobject_methods, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ + 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ + 0, /* tp_version_tag */ #endif #if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ + 0, /* tp_finalize */ #endif #ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ #if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ + 0, /* tp_prev */ #endif - 0 /* tp_next */ + 0 /* tp_next */ #endif - }; - swigpyobject_type = tmp; - type_init = 1; + }; + swigpyobject_type = tmp; + type_init = 1; #if PY_VERSION_HEX < 0x02020000 - swigpyobject_type.ob_type = &PyType_Type; + swigpyobject_type.ob_type = &PyType_Type; #else - if (PyType_Ready(&swigpyobject_type) < 0) - return NULL; + if ( PyType_Ready(&swigpyobject_type) < 0 ) + return NULL; #endif - } - return &swigpyobject_type; + } + return &swigpyobject_type; } -SWIGRUNTIME PyObject * -SwigPyObject_New(void *ptr, swig_type_info *ty, int own) -{ - SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); - if (sobj) { - sobj->ptr = ptr; - sobj->ty = ty; - sobj->own = own; - sobj->next = 0; - } - return (PyObject *)sobj; +SWIGRUNTIME PyObject* SwigPyObject_New(void* ptr, swig_type_info* ty, int own) { + SwigPyObject* sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if ( sobj ) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject*)sobj; } /* ----------------------------------------------------------------------------- @@ -2034,464 +2051,456 @@ SwigPyObject_New(void *ptr, swig_type_info *ty, int own) * ----------------------------------------------------------------------------- */ typedef struct { - PyObject_HEAD - void *pack; - swig_type_info *ty; - size_t size; + PyObject_HEAD void* pack; + swig_type_info* ty; + size_t size; } SwigPyPacked; -SWIGRUNTIME int -SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) -{ - char result[SWIG_BUFFER_SIZE]; - fputs("pack, v->size, 0, sizeof(result))) { - fputs("at ", fp); - fputs(result, fp); - } - fputs(v->ty->name,fp); - fputs(">", fp); - return 0; +SWIGRUNTIME int SwigPyPacked_print(SwigPyPacked* v, FILE* fp, int SWIGUNUSEDPARM(flags)) { + char result[SWIG_BUFFER_SIZE]; + fputs("pack, v->size, 0, sizeof(result)) ) { + fputs("at ", fp); + fputs(result, fp); + } + fputs(v->ty->name, fp); + fputs(">", fp); + return 0; } -SWIGRUNTIME PyObject * -SwigPyPacked_repr(SwigPyPacked *v) -{ - char result[SWIG_BUFFER_SIZE]; - if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { - return SWIG_Python_str_FromFormat("", result, v->ty->name); - } else { - return SWIG_Python_str_FromFormat("", v->ty->name); - } +SWIGRUNTIME PyObject* SwigPyPacked_repr(SwigPyPacked* v) { + char result[SWIG_BUFFER_SIZE]; + if ( SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result)) ) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } + else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } } -SWIGRUNTIME PyObject * -SwigPyPacked_str(SwigPyPacked *v) -{ - char result[SWIG_BUFFER_SIZE]; - if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ - return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); - } else { - return SWIG_Python_str_FromChar(v->ty->name); - } +SWIGRUNTIME PyObject* SwigPyPacked_str(SwigPyPacked* v) { + char result[SWIG_BUFFER_SIZE]; + if ( SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result)) ) { + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } + else { + return SWIG_Python_str_FromChar(v->ty->name); + } } -SWIGRUNTIME int -SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) -{ - size_t i = v->size; - size_t j = w->size; - int s = (i < j) ? -1 : ((i > j) ? 1 : 0); - return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked* v, SwigPyPacked* w) { + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((char*)v->pack, (char*)w->pack, 2 * v->size); } SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); -SWIGRUNTIME PyTypeObject* -SwigPyPacked_type(void) { - static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); - return type; +SWIGRUNTIME PyTypeObject* SwigPyPacked_type(void) { + static PyTypeObject* SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; } -SWIGRUNTIMEINLINE int -SwigPyPacked_Check(PyObject *op) { - return ((op)->ob_type == SwigPyPacked_TypeOnce()) - || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject* op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) || (strcmp((op)->ob_type->tp_name, "SwigPyPacked") == 0); } -SWIGRUNTIME void -SwigPyPacked_dealloc(PyObject *v) -{ - if (SwigPyPacked_Check(v)) { - SwigPyPacked *sobj = (SwigPyPacked *) v; - free(sobj->pack); - } - PyObject_DEL(v); +SWIGRUNTIME void SwigPyPacked_dealloc(PyObject* v) { + if ( SwigPyPacked_Check(v) ) { + SwigPyPacked* sobj = (SwigPyPacked*)v; + free(sobj->pack); + } + PyObject_DEL(v); } -SWIGRUNTIME PyTypeObject* -SwigPyPacked_TypeOnce(void) { - static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; - static PyTypeObject swigpypacked_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { -#if PY_VERSION_HEX>=0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if ( ! type_init ) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) #else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - (char *)"SwigPyPacked", /* tp_name */ - sizeof(SwigPyPacked), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ - (printfunc)SwigPyPacked_print, /* tp_print */ - (getattrfunc)0, /* tp_getattr */ - (setattrfunc)0, /* tp_setattr */ -#if PY_VERSION_HEX>=0x03000000 - 0, /* tp_reserved in 3.0.1 */ + PyObject_HEAD_INIT(NULL) 0, /* ob_size */ +#endif + (char*) "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + (printfunc)SwigPyPacked_print, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1 */ #else - (cmpfunc)SwigPyPacked_compare, /* tp_compare */ -#endif - (reprfunc)SwigPyPacked_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - (hashfunc)0, /* tp_hash */ - (ternaryfunc)0, /* tp_call */ - (reprfunc)SwigPyPacked_str, /* tp_str */ - PyObject_GenericGetAttr, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT, /* tp_flags */ - swigpacked_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ - 0, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - 0, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ + 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ + 0, /* tp_version_tag */ #endif #if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ + 0, /* tp_finalize */ #endif #ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ #if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ + 0, /* tp_prev */ #endif - 0 /* tp_next */ + 0 /* tp_next */ #endif - }; - swigpypacked_type = tmp; - type_init = 1; + }; + swigpypacked_type = tmp; + type_init = 1; #if PY_VERSION_HEX < 0x02020000 - swigpypacked_type.ob_type = &PyType_Type; + swigpypacked_type.ob_type = &PyType_Type; #else - if (PyType_Ready(&swigpypacked_type) < 0) - return NULL; + if ( PyType_Ready(&swigpypacked_type) < 0 ) + return NULL; #endif - } - return &swigpypacked_type; -} - -SWIGRUNTIME PyObject * -SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) -{ - SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); - if (sobj) { - void *pack = malloc(size); - if (pack) { - memcpy(pack, ptr, size); - sobj->pack = pack; - sobj->ty = ty; - sobj->size = size; - } else { - PyObject_DEL((PyObject *) sobj); - sobj = 0; } - } - return (PyObject *) sobj; + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject* SwigPyPacked_New(void* ptr, size_t size, swig_type_info* ty) { + SwigPyPacked* sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if ( sobj ) { + void* pack = malloc(size); + if ( pack ) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } + else { + PyObject_DEL((PyObject*)sobj); + sobj = 0; + } + } + return (PyObject*)sobj; } -SWIGRUNTIME swig_type_info * -SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) -{ - if (SwigPyPacked_Check(obj)) { - SwigPyPacked *sobj = (SwigPyPacked *)obj; - if (sobj->size != size) return 0; - memcpy(ptr, sobj->pack, size); - return sobj->ty; - } else { - return 0; - } +SWIGRUNTIME swig_type_info* SwigPyPacked_UnpackData(PyObject* obj, void* ptr, size_t size) { + if ( SwigPyPacked_Check(obj) ) { + SwigPyPacked* sobj = (SwigPyPacked*)obj; + if ( sobj->size != size ) + return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } + else { + return 0; + } } /* ----------------------------------------------------------------------------- * pointers/data manipulation * ----------------------------------------------------------------------------- */ -SWIGRUNTIMEINLINE PyObject * -_SWIG_This(void) -{ - return SWIG_Python_str_FromChar("this"); -} +SWIGRUNTIMEINLINE PyObject* _SWIG_This(void) { return SWIG_Python_str_FromChar("this"); } -static PyObject *swig_this = NULL; +static PyObject* swig_this = NULL; -SWIGRUNTIME PyObject * -SWIG_This(void) -{ - if (swig_this == NULL) - swig_this = _SWIG_This(); - return swig_this; +SWIGRUNTIME PyObject* SWIG_This(void) { + if ( swig_this == NULL ) + swig_this = _SWIG_This(); + return swig_this; } /* #define SWIG_PYTHON_SLOW_GETSET_THIS */ /* TODO: I don't know how to implement the fast getset in Python 3 right now */ -#if PY_VERSION_HEX>=0x03000000 +#if PY_VERSION_HEX >= 0x03000000 #define SWIG_PYTHON_SLOW_GETSET_THIS #endif -SWIGRUNTIME SwigPyObject * -SWIG_Python_GetSwigThis(PyObject *pyobj) -{ - PyObject *obj; +SWIGRUNTIME SwigPyObject* SWIG_Python_GetSwigThis(PyObject* pyobj) { + PyObject* obj; - if (SwigPyObject_Check(pyobj)) - return (SwigPyObject *) pyobj; + if ( SwigPyObject_Check(pyobj) ) + return (SwigPyObject*)pyobj; #ifdef SWIGPYTHON_BUILTIN - (void)obj; -# ifdef PyWeakref_CheckProxy - if (PyWeakref_CheckProxy(pyobj)) { - pyobj = PyWeakref_GET_OBJECT(pyobj); - if (pyobj && SwigPyObject_Check(pyobj)) - return (SwigPyObject*) pyobj; - } -# endif - return NULL; + (void)obj; +#ifdef PyWeakref_CheckProxy + if ( PyWeakref_CheckProxy(pyobj) ) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if ( pyobj && SwigPyObject_Check(pyobj) ) + return (SwigPyObject*)pyobj; + } +#endif + return NULL; #else - obj = 0; + obj = 0; -#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) - if (PyInstance_Check(pyobj)) { - obj = _PyInstance_Lookup(pyobj, SWIG_This()); - } else { - PyObject **dictptr = _PyObject_GetDictPtr(pyobj); - if (dictptr != NULL) { - PyObject *dict = *dictptr; - obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; - } else { +#if ( ! defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000) ) + if ( PyInstance_Check(pyobj) ) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } + else { + PyObject** dictptr = _PyObject_GetDictPtr(pyobj); + if ( dictptr != NULL ) { + PyObject* dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } + else { #ifdef PyWeakref_CheckProxy - if (PyWeakref_CheckProxy(pyobj)) { - PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); - return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; - } + if ( PyWeakref_CheckProxy(pyobj) ) { + PyObject* wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } #endif - obj = PyObject_GetAttr(pyobj,SWIG_This()); - if (obj) { - Py_DECREF(obj); - } else { - if (PyErr_Occurred()) PyErr_Clear(); - return 0; - } + obj = PyObject_GetAttr(pyobj, SWIG_This()); + if ( obj ) { + Py_DECREF(obj); + } + else { + if ( PyErr_Occurred() ) + PyErr_Clear(); + return 0; + } + } } - } #else - obj = PyObject_GetAttr(pyobj,SWIG_This()); - if (obj) { - Py_DECREF(obj); - } else { - if (PyErr_Occurred()) PyErr_Clear(); - return 0; - } + obj = PyObject_GetAttr(pyobj, SWIG_This()); + if ( obj ) { + Py_DECREF(obj); + } + else { + if ( PyErr_Occurred() ) + PyErr_Clear(); + return 0; + } #endif - if (obj && !SwigPyObject_Check(obj)) { - /* a PyObject is called 'this', try to get the 'real this' - SwigPyObject from it */ - return SWIG_Python_GetSwigThis(obj); - } - return (SwigPyObject *)obj; + if ( obj && ! SwigPyObject_Check(obj) ) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject*)obj; #endif } /* Acquire a pointer value */ -SWIGRUNTIME int -SWIG_Python_AcquirePtr(PyObject *obj, int own) { - if (own == SWIG_POINTER_OWN) { - SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); - if (sobj) { - int oldown = sobj->own; - sobj->own = own; - return oldown; - } - } - return 0; +SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject* obj, int own) { + if ( own == SWIG_POINTER_OWN ) { + SwigPyObject* sobj = SWIG_Python_GetSwigThis(obj); + if ( sobj ) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; } /* Convert a pointer value */ -SWIGRUNTIME int -SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { - int res; - SwigPyObject *sobj; - int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; - - if (!obj) - return SWIG_ERROR; - if (obj == Py_None && !implicit_conv) { - if (ptr) - *ptr = 0; - return SWIG_OK; - } - - res = SWIG_ERROR; - - sobj = SWIG_Python_GetSwigThis(obj); - if (own) - *own = 0; - while (sobj) { - void *vptr = sobj->ptr; - if (ty) { - swig_type_info *to = sobj->ty; - if (to == ty) { - /* no type cast needed */ - if (ptr) *ptr = vptr; - break; - } else { - swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); - if (!tc) { - sobj = (SwigPyObject *)sobj->next; - } else { - if (ptr) { - int newmemory = 0; - *ptr = SWIG_TypeCast(tc,vptr,&newmemory); - if (newmemory == SWIG_CAST_NEW_MEMORY) { - assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ - if (own) - *own = *own | SWIG_CAST_NEW_MEMORY; +SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject* obj, void** ptr, swig_type_info* ty, int flags, int* own) { + int res; + SwigPyObject* sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if ( ! obj ) + return SWIG_ERROR; + if ( obj == Py_None && ! implicit_conv ) { + if ( ptr ) + *ptr = 0; + return SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if ( own ) + *own = 0; + while ( sobj ) { + void* vptr = sobj->ptr; + if ( ty ) { + swig_type_info* to = sobj->ty; + if ( to == ty ) { + /* no type cast needed */ + if ( ptr ) + *ptr = vptr; + break; } - } - break; - } - } - } else { - if (ptr) *ptr = vptr; - break; - } - } - if (sobj) { - if (own) - *own = *own | sobj->own; - if (flags & SWIG_POINTER_DISOWN) { - sobj->own = 0; - } - res = SWIG_OK; - } else { - if (implicit_conv) { - SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; - if (data && !data->implicitconv) { - PyObject *klass = data->klass; - if (klass) { - PyObject *impconv; - data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ - impconv = SWIG_Python_CallFunctor(klass, obj); - data->implicitconv = 0; - if (PyErr_Occurred()) { - PyErr_Clear(); - impconv = 0; - } - if (impconv) { - SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); - if (iobj) { - void *vptr; - res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); - if (SWIG_IsOK(res)) { - if (ptr) { - *ptr = vptr; - /* transfer the ownership to 'ptr' */ - iobj->own = 0; - res = SWIG_AddCast(res); - res = SWIG_AddNewMask(res); - } else { - res = SWIG_AddCast(res); + else { + swig_cast_info* tc = SWIG_TypeCheck(to->name, ty); + if ( ! tc ) { + sobj = (SwigPyObject*)sobj->next; + } + else { + if ( ptr ) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc, vptr, &newmemory); + if ( newmemory == SWIG_CAST_NEW_MEMORY ) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use + own to delete *ptr */ + if ( own ) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; } - } } - Py_DECREF(impconv); - } } - } + else { + if ( ptr ) + *ptr = vptr; + break; + } } - if (!SWIG_IsOK(res) && obj == Py_None) { - if (ptr) - *ptr = 0; - if (PyErr_Occurred()) - PyErr_Clear(); - res = SWIG_OK; + if ( sobj ) { + if ( own ) + *own = *own | sobj->own; + if ( flags & SWIG_POINTER_DISOWN ) { + sobj->own = 0; + } + res = SWIG_OK; + } + else { + if ( implicit_conv ) { + SwigPyClientData* data = ty ? (SwigPyClientData*)ty->clientdata : 0; + if ( data && ! data->implicitconv ) { + PyObject* klass = data->klass; + if ( klass ) { + PyObject* impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if ( PyErr_Occurred() ) { + PyErr_Clear(); + impconv = 0; + } + if ( impconv ) { + SwigPyObject* iobj = SWIG_Python_GetSwigThis(impconv); + if ( iobj ) { + void* vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if ( SWIG_IsOK(res) ) { + if ( ptr ) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } + else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + } + if ( ! SWIG_IsOK(res) && obj == Py_None ) { + if ( ptr ) + *ptr = 0; + if ( PyErr_Occurred() ) + PyErr_Clear(); + res = SWIG_OK; + } } - } - return res; + return res; } /* Convert a function ptr value */ -SWIGRUNTIME int -SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { - if (!PyCFunction_Check(obj)) { - return SWIG_ConvertPtr(obj, ptr, ty, 0); - } else { - void *vptr = 0; - - /* here we get the method pointer for callbacks */ - const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); - const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; - if (desc) - desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; - if (!desc) - return SWIG_ERROR; - if (ty) { - swig_cast_info *tc = SWIG_TypeCheck(desc,ty); - if (tc) { - int newmemory = 0; - *ptr = SWIG_TypeCast(tc,vptr,&newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - } else { - return SWIG_ERROR; - } - } else { - *ptr = vptr; +SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject* obj, void** ptr, swig_type_info* ty) { + if ( ! PyCFunction_Check(obj) ) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } + else { + void* vptr = 0; + + /* here we get the method pointer for callbacks */ + const char* doc = (((PyCFunctionObject*)obj)->m_ml->ml_doc); + const char* desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if ( desc ) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if ( ! desc ) + return SWIG_ERROR; + if ( ty ) { + swig_cast_info* tc = SWIG_TypeCheck(desc, ty); + if ( tc ) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc, vptr, &newmemory); + assert(! newmemory); /* newmemory handling not yet implemented */ + } + else { + return SWIG_ERROR; + } + } + else { + *ptr = vptr; + } + return SWIG_OK; } - return SWIG_OK; - } } /* Convert a packed value value */ -SWIGRUNTIME int -SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { - swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); - if (!to) return SWIG_ERROR; - if (ty) { - if (to != ty) { - /* check type cast? */ - swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); - if (!tc) return SWIG_ERROR; - } - } - return SWIG_OK; +SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject* obj, void* ptr, size_t sz, swig_type_info* ty) { + swig_type_info* to = SwigPyPacked_UnpackData(obj, ptr, sz); + if ( ! to ) + return SWIG_ERROR; + if ( ty ) { + if ( to != ty ) { + /* check type cast? */ + swig_cast_info* tc = SWIG_TypeCheck(to->name, ty); + if ( ! tc ) + return SWIG_ERROR; + } + } + return SWIG_OK; } /* ----------------------------------------------------------------------------- @@ -2503,178 +2512,175 @@ SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *t 'this' attribute. */ -SWIGRUNTIME PyObject* -SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) -{ -#if (PY_VERSION_HEX >= 0x02020000) - PyObject *inst = 0; - PyObject *newraw = data->newraw; - if (newraw) { - inst = PyObject_Call(newraw, data->newargs, NULL); - if (inst) { -#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) - PyObject **dictptr = _PyObject_GetDictPtr(inst); - if (dictptr != NULL) { - PyObject *dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - PyDict_SetItem(dict, SWIG_This(), swig_this); - } - } +SWIGRUNTIME PyObject* SWIG_Python_NewShadowInstance(SwigPyClientData* data, PyObject* swig_this) { +#if ( PY_VERSION_HEX >= 0x02020000 ) + PyObject* inst = 0; + PyObject* newraw = data->newraw; + if ( newraw ) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if ( inst ) { +#if ! defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject** dictptr = _PyObject_GetDictPtr(inst); + if ( dictptr != NULL ) { + PyObject* dict = *dictptr; + if ( dict == NULL ) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } #else - PyObject *key = SWIG_This(); - PyObject_SetAttr(inst, key, swig_this); + PyObject* key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); #endif + } } - } else { + else { #if PY_VERSION_HEX >= 0x03000000 - inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); - if (inst) { - PyObject_SetAttr(inst, SWIG_This(), swig_this); - Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; - } + inst = ((PyTypeObject*)data->newargs)->tp_new((PyTypeObject*)data->newargs, Py_None, Py_None); + if ( inst ) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } #else - PyObject *dict = PyDict_New(); - if (dict) { - PyDict_SetItem(dict, SWIG_This(), swig_this); - inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); - } + PyObject* dict = PyDict_New(); + if ( dict ) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } #endif - } - return inst; + } + return inst; #else -#if (PY_VERSION_HEX >= 0x02010000) - PyObject *inst = 0; - PyObject *dict = PyDict_New(); - if (dict) { - PyDict_SetItem(dict, SWIG_This(), swig_this); - inst = PyInstance_NewRaw(data->newargs, dict); - Py_DECREF(dict); - } - return (PyObject *) inst; +#if ( PY_VERSION_HEX >= 0x02010000 ) + PyObject* inst = 0; + PyObject* dict = PyDict_New(); + if ( dict ) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } + return (PyObject*)inst; #else - PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); - if (inst == NULL) { - return NULL; - } - inst->in_class = (PyClassObject *)data->newargs; - Py_INCREF(inst->in_class); - inst->in_dict = PyDict_New(); - if (inst->in_dict == NULL) { - Py_DECREF(inst); - return NULL; - } + PyInstanceObject* inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); + if ( inst == NULL ) { + return NULL; + } + inst->in_class = (PyClassObject*)data->newargs; + Py_INCREF(inst->in_class); + inst->in_dict = PyDict_New(); + if ( inst->in_dict == NULL ) { + Py_DECREF(inst); + return NULL; + } #ifdef Py_TPFLAGS_HAVE_WEAKREFS - inst->in_weakreflist = NULL; + inst->in_weakreflist = NULL; #endif #ifdef Py_TPFLAGS_GC - PyObject_GC_Init(inst); + PyObject_GC_Init(inst); #endif - PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); - return (PyObject *) inst; + PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); + return (PyObject*)inst; #endif #endif } -SWIGRUNTIME void -SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) -{ - PyObject *dict; -#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) - PyObject **dictptr = _PyObject_GetDictPtr(inst); - if (dictptr != NULL) { - dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - } - PyDict_SetItem(dict, SWIG_This(), swig_this); - return; - } -#endif - dict = PyObject_GetAttrString(inst, (char*)"__dict__"); - PyDict_SetItem(dict, SWIG_This(), swig_this); - Py_DECREF(dict); +SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject* inst, PyObject* swig_this) { + PyObject* dict; +#if ( PY_VERSION_HEX >= 0x02020000 ) && ! defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject** dictptr = _PyObject_GetDictPtr(inst); + if ( dictptr != NULL ) { + dict = *dictptr; + if ( dict == NULL ) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, (char*)"__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); } -SWIGINTERN PyObject * -SWIG_Python_InitShadowInstance(PyObject *args) { - PyObject *obj[2]; - if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { - return NULL; - } else { - SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); - if (sthis) { - SwigPyObject_append((PyObject*) sthis, obj[1]); - } else { - SWIG_Python_SetSwigThis(obj[0], obj[1]); +SWIGINTERN PyObject* SWIG_Python_InitShadowInstance(PyObject* args) { + PyObject* obj[2]; + if ( ! SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj) ) { + return NULL; + } + else { + SwigPyObject* sthis = SWIG_Python_GetSwigThis(obj[0]); + if ( sthis ) { + SwigPyObject_append((PyObject*)sthis, obj[1]); + } + else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); } - return SWIG_Py_Void(); - } } /* Create a new pointer object */ -SWIGRUNTIME PyObject * -SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { - SwigPyClientData *clientdata; - PyObject * robj; - int own; - - if (!ptr) - return SWIG_Py_Void(); - - clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; - own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; - if (clientdata && clientdata->pytype) { - SwigPyObject *newobj; - if (flags & SWIG_BUILTIN_TP_INIT) { - newobj = (SwigPyObject*) self; - if (newobj->ptr) { - PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); - while (newobj->next) - newobj = (SwigPyObject *) newobj->next; - newobj->next = next_self; - newobj = (SwigPyObject *)next_self; +SWIGRUNTIME PyObject* SWIG_Python_NewPointerObj(PyObject* self, void* ptr, swig_type_info* type, int flags) { + SwigPyClientData* clientdata; + PyObject* robj; + int own; + + if ( ! ptr ) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData*)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if ( clientdata && clientdata->pytype ) { + SwigPyObject* newobj; + if ( flags & SWIG_BUILTIN_TP_INIT ) { + newobj = (SwigPyObject*)self; + if ( newobj->ptr ) { + PyObject* next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while ( newobj->next ) + newobj = (SwigPyObject*)newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject*)next_self; #ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; + newobj->dict = 0; #endif - } - } else { - newobj = PyObject_New(SwigPyObject, clientdata->pytype); + } + } + else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); #ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; + newobj->dict = 0; #endif + } + if ( newobj ) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*)newobj; + } + return SWIG_Py_Void(); } - if (newobj) { - newobj->ptr = ptr; - newobj->ty = type; - newobj->own = own; - newobj->next = 0; - return (PyObject*) newobj; - } - return SWIG_Py_Void(); - } - assert(!(flags & SWIG_BUILTIN_TP_INIT)); + assert(! (flags & SWIG_BUILTIN_TP_INIT)); - robj = SwigPyObject_New(ptr, type, own); - if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { - PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); - Py_DECREF(robj); - robj = inst; - } - return robj; + robj = SwigPyObject_New(ptr, type, own); + if ( robj && clientdata && ! (flags & SWIG_POINTER_NOSHADOW) ) { + PyObject* inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; } /* Create a new packed object */ -SWIGRUNTIMEINLINE PyObject * -SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { - return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +SWIGRUNTIMEINLINE PyObject* SWIG_Python_NewPackedObj(void* ptr, size_t sz, swig_type_info* type) { + return ptr ? SwigPyPacked_New((void*)ptr, sz, type) : SWIG_Py_Void(); } /* -----------------------------------------------------------------------------* @@ -2682,309 +2688,303 @@ SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { * -----------------------------------------------------------------------------*/ #ifdef SWIG_LINK_RUNTIME -void *SWIG_ReturnGlobalTypeList(void *); +void* SWIG_ReturnGlobalTypeList(void*); #endif -SWIGRUNTIME swig_module_info * -SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { - static void *type_pointer = (void *)0; - /* first check if module already created */ - if (!type_pointer) { +SWIGRUNTIME swig_module_info* SWIG_Python_GetModule(void* SWIGUNUSEDPARM(clientdata)) { + static void* type_pointer = (void*)0; + /* first check if module already created */ + if ( ! type_pointer ) { #ifdef SWIG_LINK_RUNTIME - type_pointer = SWIG_ReturnGlobalTypeList((void *)0); + type_pointer = SWIG_ReturnGlobalTypeList((void*)0); #else -# ifdef SWIGPY_USE_CAPSULE - type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); -# else - type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, - (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); -# endif - if (PyErr_Occurred()) { - PyErr_Clear(); - type_pointer = (void *)0; - } -#endif - } - return (swig_module_info *) type_pointer; +#ifdef SWIGPY_USE_CAPSULE + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); +#else + type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); +#endif + if ( PyErr_Occurred() ) { + PyErr_Clear(); + type_pointer = (void*)0; + } +#endif + } + return (swig_module_info*)type_pointer; } #if PY_MAJOR_VERSION < 2 /* PyModule_AddObject function was introduced in Python 2.0. The following function is copied out of Python/modsupport.c in python version 2.3.4 */ -SWIGINTERN int -PyModule_AddObject(PyObject *m, char *name, PyObject *o) -{ - PyObject *dict; - if (!PyModule_Check(m)) { - PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); - return SWIG_ERROR; - } - if (!o) { - PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); - return SWIG_ERROR; - } - - dict = PyModule_GetDict(m); - if (dict == NULL) { - /* Internal error -- modules must have a dict! */ - PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", - PyModule_GetName(m)); - return SWIG_ERROR; - } - if (PyDict_SetItemString(dict, name, o)) - return SWIG_ERROR; - Py_DECREF(o); - return SWIG_OK; +SWIGINTERN int PyModule_AddObject(PyObject* m, char* name, PyObject* o) { + PyObject* dict; + if ( ! PyModule_Check(m) ) { + PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg"); + return SWIG_ERROR; + } + if ( ! o ) { + PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value"); + return SWIG_ERROR; + } + + dict = PyModule_GetDict(m); + if ( dict == NULL ) { + /* Internal error -- modules must have a dict! */ + PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", PyModule_GetName(m)); + return SWIG_ERROR; + } + if ( PyDict_SetItemString(dict, name, o) ) + return SWIG_ERROR; + Py_DECREF(o); + return SWIG_OK; } #endif SWIGRUNTIME void #ifdef SWIGPY_USE_CAPSULE -SWIG_Python_DestroyModule(PyObject *obj) +SWIG_Python_DestroyModule(PyObject* obj) #else -SWIG_Python_DestroyModule(void *vptr) +SWIG_Python_DestroyModule(void* vptr) #endif { #ifdef SWIGPY_USE_CAPSULE - swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_module_info* swig_module = (swig_module_info*)PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); #else - swig_module_info *swig_module = (swig_module_info *) vptr; -#endif - swig_type_info **types = swig_module->types; - size_t i; - for (i =0; i < swig_module->size; ++i) { - swig_type_info *ty = types[i]; - if (ty->owndata) { - SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; - if (data) SwigPyClientData_Del(data); - } - } - Py_DECREF(SWIG_This()); - swig_this = NULL; + swig_module_info* swig_module = (swig_module_info*)vptr; +#endif + swig_type_info** types = swig_module->types; + size_t i; + for ( i = 0; i < swig_module->size; ++i ) { + swig_type_info* ty = types[i]; + if ( ty->owndata ) { + SwigPyClientData* data = (SwigPyClientData*)ty->clientdata; + if ( data ) + SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + swig_this = NULL; } -SWIGRUNTIME void -SWIG_Python_SetModule(swig_module_info *swig_module) { +SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info* swig_module) { #if PY_VERSION_HEX >= 0x03000000 - /* Add a dummy module object into sys.modules */ - PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); + /* Add a dummy module object into sys.modules */ + PyObject* module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); #else - static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ - PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); + static PyMethodDef swig_empty_runtime_method_table[] = {{NULL, NULL, 0, NULL}}; /* Sentinel */ + PyObject* module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); #endif #ifdef SWIGPY_USE_CAPSULE - PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); - if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); - } else { - Py_XDECREF(pointer); - } + PyObject* pointer = PyCapsule_New((void*)swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if ( pointer && module ) { + PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } + else { + Py_XDECREF(pointer); + } #else - PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); - if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); - } else { - Py_XDECREF(pointer); - } + PyObject* pointer = PyCObject_FromVoidPtr((void*)swig_module, SWIG_Python_DestroyModule); + if ( pointer && module ) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); + } + else { + Py_XDECREF(pointer); + } #endif } /* The python cached type query */ -SWIGRUNTIME PyObject * -SWIG_Python_TypeCache(void) { - static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); - return cache; +SWIGRUNTIME PyObject* SWIG_Python_TypeCache(void) { + static PyObject* SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; } -SWIGRUNTIME swig_type_info * -SWIG_Python_TypeQuery(const char *type) -{ - PyObject *cache = SWIG_Python_TypeCache(); - PyObject *key = SWIG_Python_str_FromChar(type); - PyObject *obj = PyDict_GetItem(cache, key); - swig_type_info *descriptor; - if (obj) { +SWIGRUNTIME swig_type_info* SWIG_Python_TypeQuery(const char* type) { + PyObject* cache = SWIG_Python_TypeCache(); + PyObject* key = SWIG_Python_str_FromChar(type); + PyObject* obj = PyDict_GetItem(cache, key); + swig_type_info* descriptor; + if ( obj ) { #ifdef SWIGPY_USE_CAPSULE - descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + descriptor = (swig_type_info*)PyCapsule_GetPointer(obj, NULL); #else - descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); + descriptor = (swig_type_info*)PyCObject_AsVoidPtr(obj); #endif - } else { - swig_module_info *swig_module = SWIG_GetModule(0); - descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); - if (descriptor) { + } + else { + swig_module_info* swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if ( descriptor ) { #ifdef SWIGPY_USE_CAPSULE - obj = PyCapsule_New((void*) descriptor, NULL, NULL); + obj = PyCapsule_New((void*)descriptor, NULL, NULL); #else - obj = PyCObject_FromVoidPtr(descriptor, NULL); + obj = PyCObject_FromVoidPtr(descriptor, NULL); #endif - PyDict_SetItem(cache, key, obj); - Py_DECREF(obj); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } } - } - Py_DECREF(key); - return descriptor; + Py_DECREF(key); + return descriptor; } /* For backward compatibility only */ -#define SWIG_POINTER_EXCEPTION 0 -#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) -#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) - -SWIGRUNTIME int -SWIG_Python_AddErrMesg(const char* mesg, int infront) -{ - if (PyErr_Occurred()) { - PyObject *type = 0; - PyObject *value = 0; - PyObject *traceback = 0; - PyErr_Fetch(&type, &value, &traceback); - if (value) { - char *tmp; - PyObject *old_str = PyObject_Str(value); - Py_XINCREF(type); - PyErr_Clear(); - if (infront) { - PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); - } else { - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); - } - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(old_str); +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int SWIG_Python_AddErrMesg(const char* mesg, int infront) { + if ( PyErr_Occurred() ) { + PyObject* type = 0; + PyObject* value = 0; + PyObject* traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if ( value ) { + char* tmp; + PyObject* old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if ( infront ) { + PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str)); + } + else { + PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } + else { + return 0; } - return 1; - } else { - return 0; - } } -SWIGRUNTIME int -SWIG_Python_ArgFail(int argnum) -{ - if (PyErr_Occurred()) { - /* add information about failing argument */ - char mesg[256]; - PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); - return SWIG_Python_AddErrMesg(mesg, 1); - } else { - return 0; - } +SWIGRUNTIME int SWIG_Python_ArgFail(int argnum) { + if ( PyErr_Occurred() ) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } + else { + return 0; + } } -SWIGRUNTIMEINLINE const char * -SwigPyObject_GetDesc(PyObject *self) -{ - SwigPyObject *v = (SwigPyObject *)self; - swig_type_info *ty = v ? v->ty : 0; - return ty ? ty->str : ""; +SWIGRUNTIMEINLINE const char* SwigPyObject_GetDesc(PyObject* self) { + SwigPyObject* v = (SwigPyObject*)self; + swig_type_info* ty = v ? v->ty : 0; + return ty ? ty->str : ""; } -SWIGRUNTIME void -SWIG_Python_TypeError(const char *type, PyObject *obj) -{ - if (type) { +SWIGRUNTIME void SWIG_Python_TypeError(const char* type, PyObject* obj) { + if ( type ) { #if defined(SWIG_COBJECT_TYPES) - if (obj && SwigPyObject_Check(obj)) { - const char *otype = (const char *) SwigPyObject_GetDesc(obj); - if (otype) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", - type, otype); - return; - } - } else + if ( obj && SwigPyObject_Check(obj) ) { + const char* otype = (const char*)SwigPyObject_GetDesc(obj); + if ( otype ) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", type, otype); + return; + } + } + else #endif - { - const char *otype = (obj ? obj->ob_type->tp_name : 0); - if (otype) { - PyObject *str = PyObject_Str(obj); - const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; - if (cstr) { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", - type, otype, cstr); - SWIG_Python_str_DelForPy3(cstr); - } else { - PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", - type, otype); - } - Py_XDECREF(str); - return; - } + { + const char* otype = (obj ? obj->ob_type->tp_name : 0); + if ( otype ) { + PyObject* str = PyObject_Str(obj); + const char* cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if ( cstr ) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } + else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } + else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); } - PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); - } else { - PyErr_Format(PyExc_TypeError, "unexpected type is received"); - } } /* Convert a pointer value, signal an exception on a type mismatch */ -SWIGRUNTIME void * -SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { - void *result; - if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { - PyErr_Clear(); +SWIGRUNTIME void* SWIG_Python_MustGetPtr(PyObject* obj, swig_type_info* ty, int SWIGUNUSEDPARM(argnum), int flags) { + void* result; + if ( SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1 ) { + PyErr_Clear(); #if SWIG_POINTER_EXCEPTION - if (flags) { - SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); - SWIG_Python_ArgFail(argnum); - } + if ( flags ) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } #endif - } - return result; + } + return result; } #ifdef SWIGPYTHON_BUILTIN -SWIGRUNTIME int -SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { - PyTypeObject *tp = obj->ob_type; - PyObject *descr; - PyObject *encoded_name; - descrsetfunc f; - int res = -1; - -# ifdef Py_USING_UNICODE - if (PyString_Check(name)) { - name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); - if (!name) - return -1; - } else if (!PyUnicode_Check(name)) -# else - if (!PyString_Check(name)) -# endif - { - PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); - return -1; - } else { - Py_INCREF(name); - } - - if (!tp->tp_dict) { - if (PyType_Ready(tp) < 0) - goto done; - } - - descr = _PyType_Lookup(tp, name); - f = NULL; - if (descr != NULL) - f = descr->ob_type->tp_descr_set; - if (!f) { - if (PyString_Check(name)) { - encoded_name = name; - Py_INCREF(name); - } else { - encoded_name = PyUnicode_AsUTF8String(name); +SWIGRUNTIME int SWIG_Python_NonDynamicSetAttr(PyObject* obj, PyObject* name, PyObject* value) { + PyTypeObject* tp = obj->ob_type; + PyObject* descr; + PyObject* encoded_name; + descrsetfunc f; + int res = -1; + +#ifdef Py_USING_UNICODE + if ( PyString_Check(name) ) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if ( ! name ) + return -1; + } + else if ( ! PyUnicode_Check(name) ) +#else + if ( ! PyString_Check(name) ) +#endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } + else { + Py_INCREF(name); + } + + if ( ! tp->tp_dict ) { + if ( PyType_Ready(tp) < 0 ) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if ( descr != NULL ) + f = descr->ob_type->tp_descr_set; + if ( ! f ) { + if ( PyString_Check(name) ) { + encoded_name = name; + Py_INCREF(name); + } + else { + encoded_name = PyUnicode_AsUTF8String(name); + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, + PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } + else { + res = f(descr, obj, value); } - PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); - Py_DECREF(encoded_name); - } else { - res = f(descr, obj, value); - } - done: - Py_DECREF(name); - return res; +done: + Py_DECREF(name); + return res; } #endif @@ -2994,11 +2994,18 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #endif +#define SWIG_exception_fail(code, msg) \ + do { \ + SWIG_Error(code, msg); \ + SWIG_fail; \ + } while ( 0 ) -#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) - -#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else - +#define SWIG_contract_assert(expr, msg) \ + if ( ! (expr) ) { \ + SWIG_Error(SWIG_RuntimeError, msg); \ + SWIG_fail; \ + } \ + else /* -------- TYPES TABLE (BEGIN) -------- */ @@ -3008,2113 +3015,2752 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIGTYPE_p_char swig_types[2] #define SWIGTYPE_p_in6_addr swig_types[3] #define SWIGTYPE_p_in_addr swig_types[4] -static swig_type_info *swig_types[6]; +static swig_type_info* swig_types[6]; static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) /* -------- TYPES TABLE (END) -------- */ -#if (PY_VERSION_HEX <= 0x02000000) -# if !defined(SWIG_PYTHON_CLASSIC) -# error "This python version requires swig to be run with the '-classic' option" -# endif +#if ( PY_VERSION_HEX <= 0x02000000 ) +#if ! defined(SWIG_PYTHON_CLASSIC) +#error "This python version requires swig to be run with the '-classic' option" +#endif #endif /*----------------------------------------------- @(target):= _SubnetTree.so ------------------------------------------------*/ #if PY_VERSION_HEX >= 0x03000000 -# define SWIG_init PyInit__SubnetTree +#define SWIG_init PyInit__SubnetTree #else -# define SWIG_init init_SubnetTree +#define SWIG_init init_SubnetTree #endif -#define SWIG_name "_SubnetTree" +#define SWIG_name "_SubnetTree" #define SWIGVERSION 0x030012 #define SWIG_VERSION SWIGVERSION -#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) -#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) +#define SWIG_as_voidptr(a) const_cast(static_cast(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a), reinterpret_cast(a)) #include namespace swig { - class SwigPtr_PyObject { - protected: - PyObject *_obj; - - public: - SwigPtr_PyObject() :_obj(0) - { - } +class SwigPtr_PyObject { +protected: + PyObject* _obj; - SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XINCREF(_obj); - SWIG_PYTHON_THREAD_END_BLOCK; - } +public: + SwigPtr_PyObject() : _obj(0) {} - SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) - { - if (initial_ref) { + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) { SWIG_PYTHON_THREAD_BEGIN_BLOCK; Py_XINCREF(_obj); SWIG_PYTHON_THREAD_END_BLOCK; - } } - SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XINCREF(item._obj); - Py_XDECREF(_obj); - _obj = item._obj; - SWIG_PYTHON_THREAD_END_BLOCK; - return *this; + SwigPtr_PyObject(PyObject* obj, bool initial_ref = true) : _obj(obj) { + if ( initial_ref ) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } } - ~SwigPtr_PyObject() - { - SWIG_PYTHON_THREAD_BEGIN_BLOCK; - Py_XDECREF(_obj); - SWIG_PYTHON_THREAD_END_BLOCK; + SwigPtr_PyObject& operator=(const SwigPtr_PyObject& item) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; } - operator PyObject *() const - { - return _obj; + ~SwigPtr_PyObject() { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; } - PyObject *operator->() const - { - return _obj; - } - }; -} + operator PyObject*() const { return _obj; } + + PyObject* operator->() const { return _obj; } +}; +} // namespace swig namespace swig { - struct SwigVar_PyObject : SwigPtr_PyObject { - SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } +struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) {} - SwigVar_PyObject & operator = (PyObject* obj) - { - Py_XDECREF(_obj); - _obj = obj; - return *this; + SwigVar_PyObject& operator=(PyObject* obj) { + Py_XDECREF(_obj); + _obj = obj; + return *this; } - }; -} +}; +} // namespace swig - #include "SubnetTree.h" +#include "SubnetTree.h" -SWIGINTERN int -SWIG_AsVal_double (PyObject *obj, double *val) -{ - int res = SWIG_TypeError; - if (PyFloat_Check(obj)) { - if (val) *val = PyFloat_AsDouble(obj); - return SWIG_OK; +SWIGINTERN int SWIG_AsVal_double(PyObject* obj, double* val) { + int res = SWIG_TypeError; + if ( PyFloat_Check(obj) ) { + if ( val ) + *val = PyFloat_AsDouble(obj); + return SWIG_OK; #if PY_VERSION_HEX < 0x03000000 - } else if (PyInt_Check(obj)) { - if (val) *val = (double) PyInt_AsLong(obj); - return SWIG_OK; + } + else if ( PyInt_Check(obj) ) { + if ( val ) + *val = (double)PyInt_AsLong(obj); + return SWIG_OK; #endif - } else if (PyLong_Check(obj)) { - double v = PyLong_AsDouble(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - double d = PyFloat_AsDouble(obj); - if (!PyErr_Occurred()) { - if (val) *val = d; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); + else if ( PyLong_Check(obj) ) { + double v = PyLong_AsDouble(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_OK; + } + else { + PyErr_Clear(); + } } - if (!dispatch) { - long v = PyLong_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); - } else { - PyErr_Clear(); - } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = d; + return SWIG_AddCast(SWIG_OK); + } + else { + PyErr_Clear(); + } + if ( ! dispatch ) { + long v = PyLong_AsLong(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } + else { + PyErr_Clear(); + } + } } - } #endif - return res; + return res; } #include - - #include -SWIGINTERNINLINE int -SWIG_CanCastAsInteger(double *d, double min, double max) { - double x = *d; - if ((min <= x && x <= max)) { - double fx = floor(x); - double cx = ceil(x); - double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ - if ((errno == EDOM) || (errno == ERANGE)) { - errno = 0; - } else { - double summ, reps, diff; - if (rd < x) { - diff = x - rd; - } else if (rd > x) { - diff = rd - x; - } else { - return 1; - } - summ = rd + x; - reps = diff/summ; - if (reps < 8*DBL_EPSILON) { - *d = rd; - return 1; - } - } - } - return 0; +SWIGINTERNINLINE int SWIG_CanCastAsInteger(double* d, double min, double max) { + double x = *d; + if ( (min <= x && x <= max) ) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ( (errno == EDOM) || (errno == ERANGE) ) { + errno = 0; + } + else { + double summ, reps, diff; + if ( rd < x ) { + diff = x - rd; + } + else if ( rd > x ) { + diff = rd - x; + } + else { + return 1; + } + summ = rd + x; + reps = diff / summ; + if ( reps < 8 * DBL_EPSILON ) { + *d = rd; + return 1; + } + } + } + return 0; } -SWIGINTERN int -SWIG_AsVal_long (PyObject *obj, long* val) -{ +SWIGINTERN int SWIG_AsVal_long(PyObject* obj, long* val) { #if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - if (val) *val = PyInt_AsLong(obj); - return SWIG_OK; - } else + if ( PyInt_Check(obj) ) { + if ( val ) + *val = PyInt_AsLong(obj); + return SWIG_OK; + } + else #endif - if (PyLong_Check(obj)) { - long v = PyLong_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; + if ( PyLong_Check(obj) ) { + long v = PyLong_AsLong(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_OK; + } + else { + PyErr_Clear(); + return SWIG_OverflowError; + } } - } #ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - long v = PyInt_AsLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { - if (val) *val = (long)(d); - return res; - } + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_AddCast(SWIG_OK); + } + else { + PyErr_Clear(); + } + if ( ! dispatch ) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double(obj, &d)); + if ( SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX) ) { + if ( val ) + *val = (long)(d); + return res; + } + } } - } #endif - return SWIG_TypeError; + return SWIG_TypeError; } -SWIGINTERN int -SWIG_AsVal_bool (PyObject *obj, bool *val) -{ - int r; - if (!PyBool_Check(obj)) - return SWIG_ERROR; - r = PyObject_IsTrue(obj); - if (r == -1) - return SWIG_ERROR; - if (val) *val = r ? true : false; - return SWIG_OK; +SWIGINTERN int SWIG_AsVal_bool(PyObject* obj, bool* val) { + int r; + if ( ! PyBool_Check(obj) ) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if ( r == -1 ) + return SWIG_ERROR; + if ( val ) + *val = r ? true : false; + return SWIG_OK; } -SWIGINTERN swig_type_info* -SWIG_pchar_descriptor(void) -{ - static int init = 0; - static swig_type_info* info = 0; - if (!init) { - info = SWIG_TypeQuery("_p_char"); - init = 1; - } - return info; +SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { + static int init = 0; + static swig_type_info* info = 0; + if ( ! init ) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; } -SWIGINTERN int -SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -{ -#if PY_VERSION_HEX>=0x03000000 +SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject* obj, char** cptr, size_t* psize, int* alloc) { +#if PY_VERSION_HEX >= 0x03000000 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (PyBytes_Check(obj)) + if ( PyBytes_Check(obj) ) #else - if (PyUnicode_Check(obj)) + if ( PyUnicode_Check(obj) ) #endif #else - if (PyString_Check(obj)) -#endif - { - char *cstr; Py_ssize_t len; -#if PY_VERSION_HEX>=0x03000000 -#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - if (!alloc && cptr) { - /* We can't allow converting without allocation, since the internal - representation of string in Python 3 is UCS-2/UCS-4 but we require - a UTF-8 representation. - TODO(bhy) More detailed explanation */ - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if(alloc) *alloc = SWIG_NEWOBJ; -#endif - PyBytes_AsStringAndSize(obj, &cstr, &len); + if ( PyString_Check(obj) ) +#endif + { + char* cstr; + Py_ssize_t len; +#if PY_VERSION_HEX >= 0x03000000 +#if ! defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + if ( ! alloc && cptr ) { + /* We can't allow converting without allocation, since the internal + representation of string in Python 3 is UCS-2/UCS-4 but we require + a UTF-8 representation. + TODO(bhy) More detailed explanation */ + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + if ( alloc ) + *alloc = SWIG_NEWOBJ; +#endif + PyBytes_AsStringAndSize(obj, &cstr, &len); #else - PyString_AsStringAndSize(obj, &cstr, &len); -#endif - if (cptr) { - if (alloc) { - /* - In python the user should not be able to modify the inner - string representation. To warranty that, if you define - SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string - buffer is always returned. - - The default behavior is just to return the pointer value, - so, be careful. - */ + PyString_AsStringAndSize(obj, &cstr, &len); +#endif + if ( cptr ) { + if ( alloc ) { + /* + In python the user should not be able to modify the inner + string representation. To warranty that, if you define + SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string + buffer is always returned. + + The default behavior is just to return the pointer value, + so, be careful. + */ #if defined(SWIG_PYTHON_SAFE_CSTRINGS) - if (*alloc != SWIG_OLDOBJ) + if ( *alloc != SWIG_OLDOBJ ) #else - if (*alloc == SWIG_NEWOBJ) -#endif - { - *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); - *alloc = SWIG_NEWOBJ; - } else { - *cptr = cstr; - *alloc = SWIG_OLDOBJ; - } - } else { -#if PY_VERSION_HEX>=0x03000000 + if ( *alloc == SWIG_NEWOBJ ) +#endif + { + *cptr = reinterpret_cast(memcpy(new char[len + 1], cstr, sizeof(char) * (len + 1))); + *alloc = SWIG_NEWOBJ; + } + else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } + else { +#if PY_VERSION_HEX >= 0x03000000 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - *cptr = PyBytes_AsString(obj); + *cptr = PyBytes_AsString(obj); #else - assert(0); /* Should never reach here with Unicode strings in Python 3 */ + assert(0); /* Should never reach here with Unicode strings in Python 3 */ #endif #else - *cptr = SWIG_Python_str_AsChar(obj); + *cptr = SWIG_Python_str_AsChar(obj); #endif - } - } - if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - Py_XDECREF(obj); + } + } + if ( psize ) + *psize = len + 1; +#if PY_VERSION_HEX >= 0x03000000 && ! defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + Py_XDECREF(obj); #endif - return SWIG_OK; - } else { + return SWIG_OK; + } + else { #if defined(SWIG_PYTHON_2_UNICODE) #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once" #endif -#if PY_VERSION_HEX<0x03000000 - if (PyUnicode_Check(obj)) { - char *cstr; Py_ssize_t len; - if (!alloc && cptr) { - return SWIG_RuntimeError; - } - obj = PyUnicode_AsUTF8String(obj); - if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) { - if (cptr) { - if (alloc) *alloc = SWIG_NEWOBJ; - *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); - } - if (psize) *psize = len + 1; +#if PY_VERSION_HEX < 0x03000000 + if ( PyUnicode_Check(obj) ) { + char* cstr; + Py_ssize_t len; + if ( ! alloc && cptr ) { + return SWIG_RuntimeError; + } + obj = PyUnicode_AsUTF8String(obj); + if ( PyString_AsStringAndSize(obj, &cstr, &len) != -1 ) { + if ( cptr ) { + if ( alloc ) + *alloc = SWIG_NEWOBJ; + *cptr = reinterpret_cast(memcpy(new char[len + 1], cstr, sizeof(char) * (len + 1))); + } + if ( psize ) + *psize = len + 1; - Py_XDECREF(obj); - return SWIG_OK; - } else { - Py_XDECREF(obj); - } - } + Py_XDECREF(obj); + return SWIG_OK; + } + else { + Py_XDECREF(obj); + } + } #endif #endif - swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); - if (pchar_descriptor) { - void* vptr = 0; - if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { - if (cptr) *cptr = (char *) vptr; - if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; - if (alloc) *alloc = SWIG_OLDOBJ; - return SWIG_OK; - } + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if ( pchar_descriptor ) { + void* vptr = 0; + if ( SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK ) { + if ( cptr ) + *cptr = (char*)vptr; + if ( psize ) + *psize = vptr ? (strlen((char*)vptr) + 1) : 0; + if ( alloc ) + *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } } - } - return SWIG_TypeError; + return SWIG_TypeError; } - - - -SWIGINTERN int -SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) -{ +SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val) { #if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - long v = PyInt_AsLong(obj); - if (v >= 0) { - if (val) *val = v; - return SWIG_OK; - } else { - return SWIG_OverflowError; + if ( PyInt_Check(obj) ) { + long v = PyInt_AsLong(obj); + if ( v >= 0 ) { + if ( val ) + *val = v; + return SWIG_OK; + } + else { + return SWIG_OverflowError; + } } - } else + else #endif - if (PyLong_Check(obj)) { - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; + if ( PyLong_Check(obj) ) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_OK; + } + else { + PyErr_Clear(); + return SWIG_OverflowError; + } } - } #ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { - if (val) *val = (unsigned long)(d); - return res; - } + { + int dispatch = 0; + unsigned long v = PyLong_AsUnsignedLong(obj); + if ( ! PyErr_Occurred() ) { + if ( val ) + *val = v; + return SWIG_AddCast(SWIG_OK); + } + else { + PyErr_Clear(); + } + if ( ! dispatch ) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double(obj, &d)); + if ( SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX) ) { + if ( val ) + *val = (unsigned long)(d); + return res; + } + } } - } #endif - return SWIG_TypeError; + return SWIG_TypeError; } #include -#if !defined(SWIG_NO_LLONG_MAX) -# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) -# define LLONG_MAX __LONG_LONG_MAX__ -# define LLONG_MIN (-LLONG_MAX - 1LL) -# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) -# endif +#if ! defined(SWIG_NO_LLONG_MAX) +#if ! defined(LLONG_MAX) && defined(__GNUC__) && defined(__LONG_LONG_MAX__) +#define LLONG_MAX __LONG_LONG_MAX__ +#define LLONG_MIN (-LLONG_MAX - 1LL) +#define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +#endif #endif -SWIGINTERN int -SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val) -{ - unsigned long v; - int res = SWIG_AsVal_unsigned_SS_long (obj, &v); - if (SWIG_IsOK(res)) { - if ((v > USHRT_MAX)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< unsigned short >(v); +SWIGINTERN int SWIG_AsVal_unsigned_SS_short(PyObject* obj, unsigned short* val) { + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long(obj, &v); + if ( SWIG_IsOK(res) ) { + if ( (v > USHRT_MAX) ) { + return SWIG_OverflowError; + } + else { + if ( val ) + *val = static_cast(v); + } } - } - return res; + return res; } -SWIGINTERNINLINE PyObject* - SWIG_From_bool (bool value) -{ - return PyBool_FromLong(value ? 1 : 0); -} +SWIGINTERNINLINE PyObject* SWIG_From_bool(bool value) { return PyBool_FromLong(value ? 1 : 0); } +SWIGINTERN PyObject* SubnetTree___contains____SWIG_1(SubnetTree* self, unsigned long addr) { + PyObject* obj = self->lookup(addr); -SWIGINTERN PyObject *SubnetTree___contains____SWIG_0(SubnetTree *self,char const *cidr,int size){ - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - PyObject* obj = self->lookup(cidr, size); - if ( obj ) - { - Py_DECREF(obj); - } - - if ( PyErr_Occurred() ) - return 0; - - if ( obj != 0 ) - Py_RETURN_TRUE; - else - Py_RETURN_FALSE; - } -SWIGINTERN PyObject *SubnetTree___contains____SWIG_1(SubnetTree *self,unsigned long addr){ - PyObject* obj = self->lookup(addr); - - if ( obj ) - { - Py_DECREF(obj); - } - - if ( PyErr_Occurred() ) - return 0; - - if ( obj != 0 ) - Py_RETURN_TRUE; - else - Py_RETURN_FALSE; - } -SWIGINTERN PyObject *SubnetTree___getitem__(SubnetTree *self,char const *cidr,int size){ - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - PyObject* data = self->lookup(cidr, size); - if ( ! data ) { - PyErr_SetObject(PyExc_KeyError, PyBytes_FromStringAndSize(cidr, size)); - return 0; - } - - return data; - } -SWIGINTERN PyObject *SubnetTree___setitem__(SubnetTree *self,char const *cidr,PyObject *data){ - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - if ( self->insert(cidr, data) ) - Py_RETURN_TRUE; - else - return 0; - } -SWIGINTERN PyObject *SubnetTree___delitem__(SubnetTree *self,char const *cidr){ - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - if ( self->remove(cidr) ) - Py_RETURN_TRUE; - else - return 0; - } -#ifdef __cplusplus -extern "C" { -#endif -SWIGINTERN PyObject *_wrap_inx_addr_sin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *arg1 = (_inx_addr *) 0 ; - in_addr arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:inx_addr_sin_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__inx_addr, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inx_addr_sin_set" "', argument " "1"" of type '" "_inx_addr *""'"); - } - arg1 = reinterpret_cast< _inx_addr * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_in_addr, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inx_addr_sin_set" "', argument " "2"" of type '" "in_addr""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inx_addr_sin_set" "', argument " "2"" of type '" "in_addr""'"); - } else { - in_addr * temp = reinterpret_cast< in_addr * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->sin = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* SubnetTree___contains____SWIG_0(SubnetTree * self, char const* cidr, int size) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + if ( PyErr_Occurred() ) + return 0; -SWIGINTERN PyObject *_wrap_inx_addr_sin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *arg1 = (_inx_addr *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - in_addr result; - - if (!PyArg_ParseTuple(args,(char *)"O:inx_addr_sin_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__inx_addr, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inx_addr_sin_get" "', argument " "1"" of type '" "_inx_addr *""'"); - } - arg1 = reinterpret_cast< _inx_addr * >(argp1); - result = ((arg1)->sin); - resultobj = SWIG_NewPointerObj((new in_addr(static_cast< const in_addr& >(result))), SWIGTYPE_p_in_addr, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} + if ( obj != 0 ) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + SWIGINTERN PyObject* SubnetTree___getitem__(SubnetTree * self, char* cidr, int size) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + PyObject* data = self->lookup(cidr, size); + if ( ! data ) { + PyErr_SetObject(PyExc_KeyError, PyBytes_FromStringAndSize(cidr, size)); + return 0; + } -SWIGINTERN PyObject *_wrap_inx_addr_sin6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *arg1 = (_inx_addr *) 0 ; - in6_addr arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:inx_addr_sin6_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__inx_addr, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inx_addr_sin6_set" "', argument " "1"" of type '" "_inx_addr *""'"); - } - arg1 = reinterpret_cast< _inx_addr * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_in6_addr, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inx_addr_sin6_set" "', argument " "2"" of type '" "in6_addr""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inx_addr_sin6_set" "', argument " "2"" of type '" "in6_addr""'"); - } else { - in6_addr * temp = reinterpret_cast< in6_addr * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - if (arg1) (arg1)->sin6 = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + return data; + } + SWIGINTERN PyObject* SubnetTree___setitem__(SubnetTree * self, char const* cidr, PyObject* data) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + if ( self->insert(cidr, data) ) + Py_RETURN_TRUE; + else + return 0; + } + SWIGINTERN PyObject* SubnetTree___delitem__(SubnetTree * self, char const* cidr) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } -SWIGINTERN PyObject *_wrap_inx_addr_sin6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *arg1 = (_inx_addr *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - in6_addr result; - - if (!PyArg_ParseTuple(args,(char *)"O:inx_addr_sin6_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__inx_addr, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inx_addr_sin6_get" "', argument " "1"" of type '" "_inx_addr *""'"); - } - arg1 = reinterpret_cast< _inx_addr * >(argp1); - result = ((arg1)->sin6); - resultobj = SWIG_NewPointerObj((new in6_addr(static_cast< const in6_addr& >(result))), SWIGTYPE_p_in6_addr, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} + if ( obj != 0 ) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + SWIGINTERN PyObject* SubnetTree___getitem__(SubnetTree * self, char const* cidr, int size) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + PyObject* data = self->lookup(cidr, size); + if ( ! data ) { + PyErr_SetObject(PyExc_KeyError, PyBytes_FromStringAndSize(cidr, size)); + return 0; + } -SWIGINTERN PyObject *_wrap_new_inx_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *result = 0 ; + return data; + } + SWIGINTERN PyObject* SubnetTree___setitem__(SubnetTree * self, char const* cidr, PyObject* data) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } - if (!PyArg_ParseTuple(args,(char *)":new_inx_addr")) SWIG_fail; - result = (_inx_addr *)new _inx_addr(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__inx_addr, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} + if ( self->insert(cidr, data) ) + Py_RETURN_TRUE; + else + return 0; + } + SWIGINTERN PyObject* SubnetTree___delitem__(SubnetTree * self, char const* cidr) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + + if ( self->remove(cidr) ) + Py_RETURN_TRUE; + else + return 0; + } +#ifdef __cplusplus + extern "C" { +#endif + SWIGINTERN PyObject* _wrap_inx_addr_sin_set(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* arg1 = (_inx_addr*)0; + in_addr arg2; + void* argp1 = 0; + int res1 = 0; + void* argp2; + int res2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:inx_addr_sin_set", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__inx_addr, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "inx_addr_sin_set" + "', argument " + "1" + " of type '" + "_inx_addr *" + "'"); + } + arg1 = reinterpret_cast<_inx_addr*>(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_in_addr, 0 | 0); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "inx_addr_sin_set" + "', argument " + "2" + " of type '" + "in_addr" + "'"); + } + if ( ! argp2 ) { + SWIG_exception_fail(SWIG_ValueError, + "invalid null reference " + "in method '" + "inx_addr_sin_set" + "', argument " + "2" + " of type '" + "in_addr" + "'"); + } + else { + in_addr* temp = reinterpret_cast(argp2); + arg2 = *temp; + if ( SWIG_IsNewObj(res2) ) + delete temp; + } + } + if ( arg1 ) + (arg1)->sin = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_delete_inx_addr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - _inx_addr *arg1 = (_inx_addr *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_inx_addr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__inx_addr, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_inx_addr" "', argument " "1"" of type '" "_inx_addr *""'"); - } - arg1 = reinterpret_cast< _inx_addr * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_inx_addr_sin_get(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* arg1 = (_inx_addr*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + in_addr result; + + if ( ! PyArg_ParseTuple(args, (char*)"O:inx_addr_sin_get", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__inx_addr, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "inx_addr_sin_get" + "', argument " + "1" + " of type '" + "_inx_addr *" + "'"); + } + arg1 = reinterpret_cast<_inx_addr*>(argp1); + result = ((arg1)->sin); + resultobj = SWIG_NewPointerObj((new in_addr(static_cast(result))), SWIGTYPE_p_in_addr, + SWIG_POINTER_OWN | 0); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *inx_addr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p__inx_addr, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} + SWIGINTERN PyObject* _wrap_inx_addr_sin6_set(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* arg1 = (_inx_addr*)0; + in6_addr arg2; + void* argp1 = 0; + int res1 = 0; + void* argp2; + int res2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:inx_addr_sin6_set", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__inx_addr, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "inx_addr_sin6_set" + "', argument " + "1" + " of type '" + "_inx_addr *" + "'"); + } + arg1 = reinterpret_cast<_inx_addr*>(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_in6_addr, 0 | 0); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "inx_addr_sin6_set" + "', argument " + "2" + " of type '" + "in6_addr" + "'"); + } + if ( ! argp2 ) { + SWIG_exception_fail(SWIG_ValueError, + "invalid null reference " + "in method '" + "inx_addr_sin6_set" + "', argument " + "2" + " of type '" + "in6_addr" + "'"); + } + else { + in6_addr* temp = reinterpret_cast(argp2); + arg2 = *temp; + if ( SWIG_IsNewObj(res2) ) + delete temp; + } + } + if ( arg1 ) + (arg1)->sin6 = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_new_SubnetTree__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - bool arg1 ; - bool val1 ; - int ecode1 = 0 ; - PyObject * obj0 = 0 ; - SubnetTree *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:new_SubnetTree",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_bool(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SubnetTree" "', argument " "1"" of type '" "bool""'"); - } - arg1 = static_cast< bool >(val1); - result = (SubnetTree *)new SubnetTree(arg1); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SubnetTree, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_inx_addr_sin6_get(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* arg1 = (_inx_addr*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + in6_addr result; + + if ( ! PyArg_ParseTuple(args, (char*)"O:inx_addr_sin6_get", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__inx_addr, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "inx_addr_sin6_get" + "', argument " + "1" + " of type '" + "_inx_addr *" + "'"); + } + arg1 = reinterpret_cast<_inx_addr*>(argp1); + result = ((arg1)->sin6); + resultobj = SWIG_NewPointerObj((new in6_addr(static_cast(result))), SWIGTYPE_p_in6_addr, + SWIG_POINTER_OWN | 0); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_new_SubnetTree__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_SubnetTree")) SWIG_fail; - result = (SubnetTree *)new SubnetTree(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SubnetTree, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_new_inx_addr(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* result = 0; + if ( ! PyArg_ParseTuple(args, (char*)":new_inx_addr") ) + SWIG_fail; + result = (_inx_addr*)new _inx_addr(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__inx_addr, SWIG_POINTER_NEW | 0); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_new_SubnetTree(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_new_SubnetTree__SWIG_1(self, args); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_bool(argv[0], NULL); - _v = SWIG_CheckState(res); + + SWIGINTERN PyObject* _wrap_delete_inx_addr(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + _inx_addr* arg1 = (_inx_addr*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:delete_inx_addr", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p__inx_addr, SWIG_POINTER_DISOWN | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "delete_inx_addr" + "', argument " + "1" + " of type '" + "_inx_addr *" + "'"); + } + arg1 = reinterpret_cast<_inx_addr*>(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; } - if (_v) { - return _wrap_new_SubnetTree__SWIG_0(self, args); + + + SWIGINTERN PyObject* inx_addr_swigregister(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* obj; + if ( ! PyArg_ParseTuple(args, (char*)"O:swigregister", &obj) ) + return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p__inx_addr, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } - } -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SubnetTree'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::SubnetTree(bool)\n" - " SubnetTree::SubnetTree()\n"); - return 0; -} + SWIGINTERN PyObject* _wrap_new_SubnetTree__SWIG_0(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + bool arg1; + bool val1; + int ecode1 = 0; + PyObject* obj0 = 0; + SubnetTree* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:new_SubnetTree", &obj0) ) + SWIG_fail; + ecode1 = SWIG_AsVal_bool(obj0, &val1); + if ( ! SWIG_IsOK(ecode1) ) { + SWIG_exception_fail(SWIG_ArgError(ecode1), + "in method '" + "new_SubnetTree" + "', argument " + "1" + " of type '" + "bool" + "'"); + } + arg1 = static_cast(val1); + result = (SubnetTree*)new SubnetTree(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SubnetTree, SWIG_POINTER_NEW | 0); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_delete_SubnetTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_SubnetTree",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubnetTree" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_new_SubnetTree__SWIG_1(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* result = 0; + if ( ! PyArg_ParseTuple(args, (char*)":new_SubnetTree") ) + SWIG_fail; + result = (SubnetTree*)new SubnetTree(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SubnetTree, SWIG_POINTER_NEW | 0); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - PyObject *arg3 = (PyObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SubnetTree_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_insert" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubnetTree_insert" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - arg3 = obj2; - result = (PyObject *)(arg1)->insert((char const *)arg2,arg3); - resultobj = result; - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} + SWIGINTERN PyObject* _wrap_new_SubnetTree(PyObject* self, PyObject* args) { + Py_ssize_t argc; + PyObject* argv[2] = {0}; + Py_ssize_t ii; -SWIGINTERN PyObject *_wrap_SubnetTree_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_insert",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_insert" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubnetTree_insert" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - result = (PyObject *)(arg1)->insert((char const *)arg2); - resultobj = result; - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 1) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 0 ) { + return _wrap_new_SubnetTree__SWIG_1(self, args); + } + if ( argc == 1 ) { + int _v; + { + int res = SWIG_AsVal_bool(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_new_SubnetTree__SWIG_0(self, args); + } + } + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'new_SubnetTree'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::SubnetTree(bool)\n" + " SubnetTree::SubnetTree()\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree_insert__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - unsigned long arg2 ; - unsigned short arg3 ; - PyObject *arg4 = (PyObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long val2 ; - int ecode2 = 0 ; - unsigned short val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOOO:SubnetTree_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_insert" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_insert" "', argument " "2"" of type '" "unsigned long""'"); - } - arg2 = static_cast< unsigned long >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SubnetTree_insert" "', argument " "3"" of type '" "unsigned short""'"); - } - arg3 = static_cast< unsigned short >(val3); - arg4 = obj3; - result = (PyObject *)(arg1)->insert(arg2,arg3,arg4); - resultobj = result; - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_delete_SubnetTree(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:delete_SubnetTree", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, SWIG_POINTER_DISOWN | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "delete_SubnetTree" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_insert__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - unsigned long arg2 ; - unsigned short arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long val2 ; - int ecode2 = 0 ; - unsigned short val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SubnetTree_insert",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_insert" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_insert" "', argument " "2"" of type '" "unsigned long""'"); - } - arg2 = static_cast< unsigned long >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SubnetTree_insert" "', argument " "3"" of type '" "unsigned short""'"); - } - arg3 = static_cast< unsigned short >(val3); - result = (PyObject *)(arg1)->insert(arg2,arg3); - resultobj = result; - return resultobj; -fail: - return NULL; -} + + SWIGINTERN PyObject* _wrap_SubnetTree_insert__SWIG_0(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + PyObject* arg3 = (PyObject*)0; + void* argp1 = 0; + int res1 = 0; + int res2; + char* buf2 = 0; + int alloc2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_insert", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_insert" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "SubnetTree_insert" + "', argument " + "2" + " of type '" + "char const *" + "'"); + } + arg2 = reinterpret_cast(buf2); + arg3 = obj2; + result = (PyObject*)(arg1)->insert((char const*)arg2, arg3); + resultobj = result; + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_insert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SubnetTree_insert__SWIG_1(self, args); - } + SWIGINTERN PyObject* _wrap_SubnetTree_insert__SWIG_1(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + void* argp1 = 0; + int res1 = 0; + int res2; + char* buf2 = 0; + int alloc2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_insert", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_insert" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "SubnetTree_insert" + "', argument " + "2" + " of type '" + "char const *" + "'"); + } + arg2 = reinterpret_cast(buf2); + result = (PyObject*)(arg1)->insert((char const*)arg2); + resultobj = result; + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); - _v = SWIG_CheckState(res); + + + SWIGINTERN PyObject* _wrap_SubnetTree_insert__SWIG_2(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + unsigned short arg3; + PyObject* arg4 = (PyObject*)0; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + unsigned short val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* obj3 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOOO:SubnetTree_insert", &obj0, &obj1, &obj2, &obj3) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_insert" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); } - if (_v) { - return _wrap_SubnetTree_insert__SWIG_3(self, args); + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_insert" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); } - } + arg2 = static_cast(val2); + ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_insert" + "', argument " + "3" + " of type '" + "unsigned short" + "'"); + } + arg3 = static_cast(val3); + arg4 = obj3; + result = (PyObject*)(arg1)->insert(arg2, arg3, arg4); + resultobj = result; + return resultobj; + fail: + return NULL; } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - _v = (argv[2] != 0); - if (_v) { - return _wrap_SubnetTree_insert__SWIG_0(self, args); + + + SWIGINTERN PyObject* _wrap_SubnetTree_insert__SWIG_3(PyObject* SWIGUNUSEDPARM(self), PyObject* args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + unsigned short arg3; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + unsigned short val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_insert", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_insert" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); } - } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_insert" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); + } + arg2 = static_cast(val2); + ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_insert" + "', argument " + "3" + " of type '" + "unsigned short" + "'"); + } + arg3 = static_cast(val3); + result = (PyObject*)(arg1)->insert(arg2, arg3); + resultobj = result; + return resultobj; + fail: + return NULL; } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); - _v = SWIG_CheckState(res); + + + SWIGINTERN PyObject* _wrap_SubnetTree_insert(PyObject* self, PyObject* args) { + Py_ssize_t argc; + PyObject* argv[5] = {0}; + Py_ssize_t ii; + + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 4) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); } - if (_v) { - _v = (argv[3] != 0); - if (_v) { - return _wrap_SubnetTree_insert__SWIG_2(self, args); - } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + return _wrap_SubnetTree_insert__SWIG_1(self, args); + } + } + } + if ( argc == 3 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_insert__SWIG_3(self, args); + } + } + } } - } } - } -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree_insert'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::insert(char const *,PyObject *)\n" - " SubnetTree::insert(char const *)\n" - " SubnetTree::insert(unsigned long,unsigned short,PyObject *)\n" - " SubnetTree::insert(unsigned long,unsigned short)\n"); - return 0; -} + fail: SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_remove'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::remove(char const *)\n" + " SubnetTree::remove(unsigned long,unsigned short)\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_remove",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_remove" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubnetTree_remove" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - result = (PyObject *)(arg1)->remove((char const *)arg2); - resultobj = result; - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_lookup__SWIG_0(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + int arg3; + void* argp1 = 0; + int res1 = 0; + PyObject* ascii2; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + { ascii2 = NULL; } + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_lookup", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_lookup" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + Py_ssize_t len; -SWIGINTERN PyObject *_wrap_SubnetTree_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - unsigned long arg2 ; - unsigned short arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long val2 ; - int ecode2 = 0 ; - unsigned short val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SubnetTree_remove",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_remove" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_remove" "', argument " "2"" of type '" "unsigned long""'"); - } - arg2 = static_cast< unsigned long >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SubnetTree_remove" "', argument " "3"" of type '" "unsigned short""'"); - } - arg3 = static_cast< unsigned short >(val3); - result = (PyObject *)(arg1)->remove(arg2,arg3); - resultobj = result; - return resultobj; -fail: - return NULL; -} +#if PY_MAJOR_VERSION >= 3 + if ( PyUnicode_Check(obj1) ) { + ascii2 = PyUnicode_AsASCIIString(obj1); + if ( ! ascii2 ) { + PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_remove(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SubnetTree_remove__SWIG_0(self, args); - } + PyBytes_AsStringAndSize(ascii2, &arg2, &len); + arg3 = len; + } + else if ( PyBytes_Check(obj1) ) { + PyBytes_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } + else { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } +#else + if ( ! PyString_Check(obj1) ) { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); - _v = SWIG_CheckState(res); + else { + PyString_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } +#endif + + result = (PyObject*)((SubnetTree const*)arg1)->lookup((char const*)arg2, arg3); + resultobj = result; + { Py_XDECREF(ascii2); } + return resultobj; + fail: { Py_XDECREF(ascii2); } + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_lookup__SWIG_1(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_lookup", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_lookup" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); } - if (_v) { - return _wrap_SubnetTree_remove__SWIG_1(self, args); + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_lookup" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); } - } + arg2 = static_cast(val2); + result = (PyObject*)((SubnetTree const*)arg1)->lookup(arg2); + resultobj = result; + return resultobj; + fail: + return NULL; } - } -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree_remove'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::remove(char const *)\n" - " SubnetTree::remove(unsigned long,unsigned short)\n"); - return 0; -} + SWIGINTERN PyObject* _wrap_SubnetTree_lookup(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[3] = {0}; + Py_ssize_t ii; -SWIGINTERN PyObject *_wrap_SubnetTree_lookup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *ascii2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - { - ascii2 = NULL; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_lookup",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_lookup" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - - Py_ssize_t len; + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 2) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_lookup__SWIG_1(self, args); + } + } + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + // The typemap above will check types and throw a type error when + // needed, so just let everything through. + _v = 1; + } + if ( _v ) { + if ( argc <= 2 ) { + return _wrap_SubnetTree_lookup__SWIG_0(self, args); + } + return _wrap_SubnetTree_lookup__SWIG_0(self, args); + } + } + } + + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_lookup'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::lookup(char const *,int) const\n" + " SubnetTree::lookup(unsigned long) const\n"); + return 0; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_search_all(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + int arg3; + void* argp1 = 0; + int res1 = 0; + PyObject* ascii2; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + { ascii2 = NULL; } + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_search_all", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_search_all" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + + Py_ssize_t len; #if PY_MAJOR_VERSION >= 3 - if ( PyUnicode_Check(obj1) ) - { - ascii2 = PyUnicode_AsASCIIString(obj1); + if ( PyUnicode_Check(obj1) ) { + ascii2 = PyUnicode_AsASCIIString(obj1); - if ( ! ascii2 ) - { - PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); - return NULL; - } - - PyBytes_AsStringAndSize(ascii2, &arg2, &len); - arg3 = len; - } - else if ( PyBytes_Check(obj1) ) - { - PyBytes_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } - else - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } + if ( ! ascii2 ) { + PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); + return NULL; + } + + PyBytes_AsStringAndSize(ascii2, &arg2, &len); + arg3 = len; + } + else if ( PyBytes_Check(obj1) ) { + PyBytes_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } + else { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } #else - if ( ! PyString_Check(obj1) ) - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } - else - { - PyString_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } -#endif - - result = (PyObject *)((SubnetTree const *)arg1)->lookup((char const *)arg2,arg3); - resultobj = result; - { - Py_XDECREF(ascii2); - } - return resultobj; -fail: - { - Py_XDECREF(ascii2); - } - return NULL; -} + if ( ! PyString_Check(obj1) ) { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } + else { + PyString_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } +#endif + + result = (PyObject*)((SubnetTree const*)arg1)->search_all((char const*)arg2, arg3); + resultobj = result; + { Py_XDECREF(ascii2); } + return resultobj; + fail: { Py_XDECREF(ascii2); } + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_0(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + bool arg2; + bool arg3; + void* argp1 = 0; + int res1 = 0; + bool val2; + int ecode2 = 0; + bool val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_prefixes", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_prefixes" + "', argument " + "2" + " of type '" + "bool" + "'"); + } + arg2 = static_cast(val2); + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_prefixes" + "', argument " + "3" + " of type '" + "bool" + "'"); + } + arg3 = static_cast(val3); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(arg2, arg3); + resultobj = result; + return resultobj; + fail: + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_1(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + bool arg2; + void* argp1 = 0; + int res1 = 0; + bool val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_prefixes", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_prefixes" + "', argument " + "2" + " of type '" + "bool" + "'"); + } + arg2 = static_cast(val2); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(arg2); + resultobj = result; + return resultobj; + fail: + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_2(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:SubnetTree_prefixes", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(); + resultobj = result; + return resultobj; + fail: + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[4] = {0}; + Py_ssize_t ii; + + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 3) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 1 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + return _wrap_SubnetTree_prefixes__SWIG_2(self, args); + } + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + _v = (argv[3] != 0); + if ( _v ) { + return _wrap_SubnetTree_insert__SWIG_2(self, args); + } + } + } + } + } + + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_insert'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::insert(char const *,PyObject *)\n" + " SubnetTree::insert(char const *)\n" + " SubnetTree::insert(unsigned long,unsigned short,PyObject *)\n" + " SubnetTree::insert(unsigned long,unsigned short)\n"); + return 0; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_remove__SWIG_0(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + void* argp1 = 0; + int res1 = 0; + int res2; + char* buf2 = 0; + int alloc2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_remove", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_remove" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "SubnetTree_remove" + "', argument " + "2" + " of type '" + "char const *" + "'"); + } + arg2 = reinterpret_cast(buf2); + result = (PyObject*)(arg1)->remove((char const*)arg2); + resultobj = result; + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_remove__SWIG_1(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + unsigned short arg3; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + unsigned short val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_remove", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_remove" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_remove" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); + } + arg2 = static_cast(val2); + ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_remove" + "', argument " + "3" + " of type '" + "unsigned short" + "'"); + } + arg3 = static_cast(val3); + result = (PyObject*)(arg1)->remove(arg2, arg3); + resultobj = result; + return resultobj; + fail: + return NULL; + } + + + SWIGINTERN PyObject* _wrap_SubnetTree_remove(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[4] = {0}; + Py_ssize_t ii; + + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 3) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + return _wrap_SubnetTree_remove__SWIG_0(self, args); + } + } + } + if ( argc == 3 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_remove__SWIG_1(self, args); + } + } + } + } + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_remove'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::remove(char const *)\n" + " SubnetTree::remove(unsigned long,unsigned short)\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree_lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - unsigned long arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_lookup",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_lookup" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_lookup" "', argument " "2"" of type '" "unsigned long""'"); - } - arg2 = static_cast< unsigned long >(val2); - result = (PyObject *)((SubnetTree const *)arg1)->lookup(arg2); - resultobj = result; - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_lookup__SWIG_0(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + int arg3; + void* argp1 = 0; + int res1 = 0; + int res2; + char* buf2 = 0; + int alloc2 = 0; + int val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_lookup", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_lookup" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "SubnetTree_lookup" + "', argument " + "2" + " of type '" + "char const *" + "'"); + } + arg2 = reinterpret_cast(buf2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_lookup" + "', argument " + "3" + " of type '" + "int" + "'"); + } + arg3 = static_cast(val3); + result = (PyObject*)((SubnetTree const*)arg1)->lookup((char const*)arg2, arg3); + resultobj = result; + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_lookup(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SubnetTree_lookup__SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - // The typemap above will check types and throw a type error when - // needed, so just let everything through. - _v = 1; - } - if (_v) { - if (argc <= 2) { - return _wrap_SubnetTree_lookup__SWIG_0(self, args); - } - return _wrap_SubnetTree_lookup__SWIG_0(self, args); - } - } - } -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree_lookup'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::lookup(char const *,int) const\n" - " SubnetTree::lookup(unsigned long) const\n"); - return 0; -} + SWIGINTERN PyObject* _wrap_SubnetTree_lookup__SWIG_1(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_lookup", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_lookup" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_lookup" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); + } + arg2 = static_cast(val2); + result = (PyObject*)((SubnetTree const*)arg1)->lookup(arg2); + resultobj = result; + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_search_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *ascii2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - { - ascii2 = NULL; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_search_all",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_search_all" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - - Py_ssize_t len; + SWIGINTERN PyObject* _wrap_SubnetTree_lookup(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[4] = {0}; + Py_ssize_t ii; -#if PY_MAJOR_VERSION >= 3 - if ( PyUnicode_Check(obj1) ) - { - ascii2 = PyUnicode_AsASCIIString(obj1); + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 3) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_lookup__SWIG_1(self, args); + } + } + } + if ( argc == 3 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_lookup__SWIG_0(self, args); + } + } + } + } - if ( ! ascii2 ) - { - PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); - return NULL; - } - - PyBytes_AsStringAndSize(ascii2, &arg2, &len); - arg3 = len; - } - else if ( PyBytes_Check(obj1) ) - { - PyBytes_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } - else - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } -#else - if ( ! PyString_Check(obj1) ) - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } - else - { - PyString_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } -#endif - - result = (PyObject *)((SubnetTree const *)arg1)->search_all((char const *)arg2,arg3); - resultobj = result; - { - Py_XDECREF(ascii2); - } - return resultobj; -fail: - { - Py_XDECREF(ascii2); - } - return NULL; -} + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_lookup'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::lookup(char const *,int) const\n" + " SubnetTree::lookup(unsigned long) const\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree_prefixes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - bool arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SubnetTree_prefixes",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_prefixes" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_prefixes" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SubnetTree_prefixes" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - result = (PyObject *)((SubnetTree const *)arg1)->prefixes(arg2,arg3); - resultobj = result; - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_0(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + bool arg2; + bool arg3; + void* argp1 = 0; + int res1 = 0; + bool val2; + int ecode2 = 0; + bool val3; + int ecode3 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* obj2 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OOO:SubnetTree_prefixes", &obj0, &obj1, &obj2) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_prefixes" + "', argument " + "2" + " of type '" + "bool" + "'"); + } + arg2 = static_cast(val2); + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if ( ! SWIG_IsOK(ecode3) ) { + SWIG_exception_fail(SWIG_ArgError(ecode3), + "in method '" + "SubnetTree_prefixes" + "', argument " + "3" + " of type '" + "bool" + "'"); + } + arg3 = static_cast(val3); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(arg2, arg3); + resultobj = result; + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_prefixes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_prefixes",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_prefixes" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_prefixes" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - result = (PyObject *)((SubnetTree const *)arg1)->prefixes(arg2); - resultobj = result; - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_1(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + bool arg2; + void* argp1 = 0; + int res1 = 0; + bool val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_prefixes", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_prefixes" + "', argument " + "2" + " of type '" + "bool" + "'"); + } + arg2 = static_cast(val2); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(arg2); + resultobj = result; + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_prefixes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SubnetTree_prefixes",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_prefixes" "', argument " "1"" of type '" "SubnetTree const *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - result = (PyObject *)((SubnetTree const *)arg1)->prefixes(); - resultobj = result; - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes__SWIG_2(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:SubnetTree_prefixes", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_prefixes" + "', argument " + "1" + " of type '" + "SubnetTree const *" + "'"); + } + arg1 = reinterpret_cast(argp1); + result = (PyObject*)((SubnetTree const*)arg1)->prefixes(); + resultobj = result; + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_prefixes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SubnetTree_prefixes__SWIG_2(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SubnetTree_prefixes__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SubnetTree_prefixes__SWIG_0(self, args); - } - } - } - } + SWIGINTERN PyObject* _wrap_SubnetTree_prefixes(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[4] = {0}; + Py_ssize_t ii; -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree_prefixes'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::prefixes(bool,bool) const\n" - " SubnetTree::prefixes(bool) const\n" - " SubnetTree::prefixes() const\n"); - return 0; -} + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 3) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 1 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + return _wrap_SubnetTree_prefixes__SWIG_2(self, args); + } + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_prefixes__SWIG_1(self, args); + } + } + } + if ( argc == 3 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_prefixes__SWIG_0(self, args); + } + } + } + } + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_prefixes'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::prefixes(bool,bool) const\n" + " SubnetTree::prefixes(bool) const\n" + " SubnetTree::prefixes() const\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree_get_binary_lookup_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - bool result; - - if (!PyArg_ParseTuple(args,(char *)"O:SubnetTree_get_binary_lookup_mode",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_get_binary_lookup_mode" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - result = (bool)(arg1)->get_binary_lookup_mode(); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_get_binary_lookup_mode(PyObject * SWIGUNUSEDPARM(self), + PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + bool result; + + if ( ! PyArg_ParseTuple(args, (char*)"O:SubnetTree_get_binary_lookup_mode", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_get_binary_lookup_mode" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + result = (bool)(arg1)->get_binary_lookup_mode(); + resultobj = SWIG_From_bool(static_cast(result)); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_set_binary_lookup_mode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree_set_binary_lookup_mode",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_set_binary_lookup_mode" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree_set_binary_lookup_mode" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - (arg1)->set_binary_lookup_mode(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_set_binary_lookup_mode__SWIG_0(PyObject * SWIGUNUSEDPARM(self), + PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + bool arg2; + void* argp1 = 0; + int res1 = 0; + bool val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree_set_binary_lookup_mode", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_set_binary_lookup_mode" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree_set_binary_lookup_mode" + "', argument " + "2" + " of type '" + "bool" + "'"); + } + arg2 = static_cast(val2); + (arg1)->set_binary_lookup_mode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_set_binary_lookup_mode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SubnetTree_set_binary_lookup_mode",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree_set_binary_lookup_mode" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - (arg1)->set_binary_lookup_mode(); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree_set_binary_lookup_mode__SWIG_1(PyObject * SWIGUNUSEDPARM(self), + PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + void* argp1 = 0; + int res1 = 0; + PyObject* obj0 = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"O:SubnetTree_set_binary_lookup_mode", &obj0) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree_set_binary_lookup_mode" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + (arg1)->set_binary_lookup_mode(); + resultobj = SWIG_Py_Void(); + return resultobj; + fail: + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree_set_binary_lookup_mode(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SubnetTree_set_binary_lookup_mode__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SubnetTree_set_binary_lookup_mode__SWIG_0(self, args); - } - } - } -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree_set_binary_lookup_mode'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::set_binary_lookup_mode(bool)\n" - " SubnetTree::set_binary_lookup_mode()\n"); - return 0; -} + SWIGINTERN PyObject* _wrap_SubnetTree_set_binary_lookup_mode(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[3] = {0}; + Py_ssize_t ii; + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 2) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 1 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + return _wrap_SubnetTree_set_binary_lookup_mode__SWIG_1(self, args); + } + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree_set_binary_lookup_mode__SWIG_0(self, args); + } + } + } -SWIGINTERN PyObject *_wrap_SubnetTree___contains____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *ascii2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - { - ascii2 = NULL; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree___contains__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree___contains__" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - - Py_ssize_t len; + fail: + SWIG_SetErrorMsg( + PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree_set_binary_lookup_mode'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::set_binary_lookup_mode(bool)\n" + " SubnetTree::set_binary_lookup_mode()\n"); + return 0; + } -#if PY_MAJOR_VERSION >= 3 - if ( PyUnicode_Check(obj1) ) - { - ascii2 = PyUnicode_AsASCIIString(obj1); - if ( ! ascii2 ) - { - PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); - return NULL; - } - - PyBytes_AsStringAndSize(ascii2, &arg2, &len); - arg3 = len; - } - else if ( PyBytes_Check(obj1) ) - { - PyBytes_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } - else - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } -#else - if ( ! PyString_Check(obj1) ) - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } - else - { - PyString_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } -#endif - - result = (PyObject *)SubnetTree___contains____SWIG_0(arg1,(char const *)arg2,arg3); - resultobj = result; - { - Py_XDECREF(ascii2); - } - return resultobj; -fail: - { - Py_XDECREF(ascii2); - } - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree___contains____SWIG_0(PyObject * SWIGUNUSEDPARM(self), + PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + int arg3; + void* argp1 = 0; + int res1 = 0; + PyObject* ascii2; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + { ascii2 = NULL; } + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree___contains__", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree___contains__" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + Py_ssize_t len; -SWIGINTERN PyObject *_wrap_SubnetTree___contains____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - unsigned long arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree___contains__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree___contains__" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubnetTree___contains__" "', argument " "2"" of type '" "unsigned long""'"); - } - arg2 = static_cast< unsigned long >(val2); - result = (PyObject *)SubnetTree___contains____SWIG_1(arg1,arg2); - resultobj = result; - return resultobj; -fail: - return NULL; -} +#if PY_MAJOR_VERSION >= 3 + if ( PyUnicode_Check(obj1) ) { + ascii2 = PyUnicode_AsASCIIString(obj1); + if ( ! ascii2 ) { + PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree___contains__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SubnetTree___contains____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - // The typemap above will check types and throw a type error when - // needed, so just let everything through. - _v = 1; - } - if (_v) { - if (argc <= 2) { - return _wrap_SubnetTree___contains____SWIG_0(self, args); - } - return _wrap_SubnetTree___contains____SWIG_0(self, args); - } - } - } + PyBytes_AsStringAndSize(ascii2, &arg2, &len); + arg3 = len; + } + else if ( PyBytes_Check(obj1) ) { + PyBytes_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } + else { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } +#else + if ( ! PyString_Check(obj1) ) { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } + else { + PyString_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } +#endif -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SubnetTree___contains__'.\n" - " Possible C/C++ prototypes are:\n" - " SubnetTree::__contains__(char const *,int)\n" - " SubnetTree::__contains__(unsigned long)\n"); - return 0; -} + result = (PyObject*)SubnetTree___contains____SWIG_0(arg1, (char const*)arg2, arg3); + resultobj = result; + { Py_XDECREF(ascii2); } + return resultobj; + fail: { Py_XDECREF(ascii2); } + return NULL; + } -SWIGINTERN PyObject *_wrap_SubnetTree___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *ascii2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - { - ascii2 = NULL; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree___getitem__" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - - Py_ssize_t len; + SWIGINTERN PyObject* _wrap_SubnetTree___contains____SWIG_1(PyObject * SWIGUNUSEDPARM(self), + PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + unsigned long arg2; + void* argp1 = 0; + int res1 = 0; + unsigned long val2; + int ecode2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree___contains__", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree___contains__" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2); + if ( ! SWIG_IsOK(ecode2) ) { + SWIG_exception_fail(SWIG_ArgError(ecode2), + "in method '" + "SubnetTree___contains__" + "', argument " + "2" + " of type '" + "unsigned long" + "'"); + } + arg2 = static_cast(val2); + result = (PyObject*)SubnetTree___contains____SWIG_1(arg1, arg2); + resultobj = result; + return resultobj; + fail: + return NULL; + } -#if PY_MAJOR_VERSION >= 3 - if ( PyUnicode_Check(obj1) ) - { - ascii2 = PyUnicode_AsASCIIString(obj1); - if ( ! ascii2 ) - { - PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); - return NULL; - } - - PyBytes_AsStringAndSize(ascii2, &arg2, &len); - arg3 = len; - } - else if ( PyBytes_Check(obj1) ) - { - PyBytes_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } - else - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } -#else - if ( ! PyString_Check(obj1) ) - { - PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); - return NULL; - } - else - { - PyString_AsStringAndSize(obj1, &arg2, &len); - arg3 = len; - } -#endif - - result = (PyObject *)SubnetTree___getitem__(arg1,(char const *)arg2,arg3); - resultobj = result; - { - Py_XDECREF(ascii2); - } - return resultobj; -fail: - { - Py_XDECREF(ascii2); - } - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree___contains__(PyObject * self, PyObject * args) { + Py_ssize_t argc; + PyObject* argv[3] = {0}; + Py_ssize_t ii; + if ( ! PyTuple_Check(args) ) + SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for ( ii = 0; (ii < 2) && (ii < argc); ii++ ) { + argv[ii] = PyTuple_GET_ITEM(args, ii); + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if ( _v ) { + return _wrap_SubnetTree___contains____SWIG_1(self, args); + } + } + } + if ( argc == 2 ) { + int _v; + void* vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SubnetTree, 0); + _v = SWIG_CheckState(res); + if ( _v ) { + { + // The typemap above will check types and throw a type error when + // needed, so just let everything through. + _v = 1; + } + if ( _v ) { + if ( argc <= 2 ) { + return _wrap_SubnetTree___contains____SWIG_0(self, args); + } + return _wrap_SubnetTree___contains____SWIG_0(self, args); + } + } + } -SWIGINTERN PyObject *_wrap_SubnetTree___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - PyObject *arg3 = (PyObject *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SubnetTree___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree___setitem__" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubnetTree___setitem__" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - arg3 = obj2; - result = (PyObject *)SubnetTree___setitem__(arg1,(char const *)arg2,arg3); - resultobj = result; - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} + fail: + SWIG_SetErrorMsg( + PyExc_NotImplementedError, + "Wrong number or type of arguments for overloaded function 'SubnetTree___contains__'.\n" + " Possible C/C++ prototypes are:\n" + " SubnetTree::__contains__(char const *,int)\n" + " SubnetTree::__contains__(unsigned long)\n"); + return 0; + } -SWIGINTERN PyObject *_wrap_SubnetTree___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SubnetTree *arg1 = (SubnetTree *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SubnetTree___delitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SubnetTree, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubnetTree___delitem__" "', argument " "1"" of type '" "SubnetTree *""'"); - } - arg1 = reinterpret_cast< SubnetTree * >(argp1); - res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubnetTree___delitem__" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - result = (PyObject *)SubnetTree___delitem__(arg1,(char const *)arg2); - resultobj = result; - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} + SWIGINTERN PyObject* _wrap_SubnetTree___getitem__(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + int arg3; + void* argp1 = 0; + int res1 = 0; + PyObject* ascii2; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + { ascii2 = NULL; } + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree___getitem__", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree___getitem__" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + Py_ssize_t len; -SWIGINTERN PyObject *SubnetTree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_SubnetTree, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} +#if PY_MAJOR_VERSION >= 3 + if ( PyUnicode_Check(obj1) ) { + ascii2 = PyUnicode_AsASCIIString(obj1); -static PyMethodDef SwigMethods[] = { - { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, - { (char *)"inx_addr_sin_set", _wrap_inx_addr_sin_set, METH_VARARGS, NULL}, - { (char *)"inx_addr_sin_get", _wrap_inx_addr_sin_get, METH_VARARGS, NULL}, - { (char *)"inx_addr_sin6_set", _wrap_inx_addr_sin6_set, METH_VARARGS, NULL}, - { (char *)"inx_addr_sin6_get", _wrap_inx_addr_sin6_get, METH_VARARGS, NULL}, - { (char *)"new_inx_addr", _wrap_new_inx_addr, METH_VARARGS, NULL}, - { (char *)"delete_inx_addr", _wrap_delete_inx_addr, METH_VARARGS, NULL}, - { (char *)"inx_addr_swigregister", inx_addr_swigregister, METH_VARARGS, NULL}, - { (char *)"new_SubnetTree", _wrap_new_SubnetTree, METH_VARARGS, NULL}, - { (char *)"delete_SubnetTree", _wrap_delete_SubnetTree, METH_VARARGS, NULL}, - { (char *)"SubnetTree_insert", _wrap_SubnetTree_insert, METH_VARARGS, NULL}, - { (char *)"SubnetTree_remove", _wrap_SubnetTree_remove, METH_VARARGS, NULL}, - { (char *)"SubnetTree_lookup", _wrap_SubnetTree_lookup, METH_VARARGS, NULL}, - { (char *)"SubnetTree_search_all", _wrap_SubnetTree_search_all, METH_VARARGS, NULL}, - { (char *)"SubnetTree_prefixes", _wrap_SubnetTree_prefixes, METH_VARARGS, NULL}, - { (char *)"SubnetTree_get_binary_lookup_mode", _wrap_SubnetTree_get_binary_lookup_mode, METH_VARARGS, NULL}, - { (char *)"SubnetTree_set_binary_lookup_mode", _wrap_SubnetTree_set_binary_lookup_mode, METH_VARARGS, NULL}, - { (char *)"SubnetTree___contains__", _wrap_SubnetTree___contains__, METH_VARARGS, NULL}, - { (char *)"SubnetTree___getitem__", _wrap_SubnetTree___getitem__, METH_VARARGS, NULL}, - { (char *)"SubnetTree___setitem__", _wrap_SubnetTree___setitem__, METH_VARARGS, NULL}, - { (char *)"SubnetTree___delitem__", _wrap_SubnetTree___delitem__, METH_VARARGS, NULL}, - { (char *)"SubnetTree_swigregister", SubnetTree_swigregister, METH_VARARGS, NULL}, - { NULL, NULL, 0, NULL } -}; + if ( ! ascii2 ) { + PyErr_SetString(PyExc_TypeError, "Expected a ASCII encodable string or bytes"); + return NULL; + } + PyBytes_AsStringAndSize(ascii2, &arg2, &len); + arg3 = len; + } + else if ( PyBytes_Check(obj1) ) { + PyBytes_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } + else { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } +#else + if ( ! PyString_Check(obj1) ) { + PyErr_SetString(PyExc_TypeError, "Expected a string or bytes"); + return NULL; + } + else { + PyString_AsStringAndSize(obj1, &arg2, &len); + arg3 = len; + } +#endif -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + result = (PyObject*)SubnetTree___getitem__(arg1, (char const*)arg2, arg3); + resultobj = result; + { Py_XDECREF(ascii2); } + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; + } -static swig_type_info _swigt__p_SubnetTree = {"_p_SubnetTree", "SubnetTree *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p__inx_addr = {"_p__inx_addr", "_inx_addr *|inx_addr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_in6_addr = {"_p_in6_addr", "in6_addr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_in_addr = {"_p_in_addr", "in_addr *", 0, 0, (void*)0, 0}; -static swig_type_info *swig_type_initial[] = { - &_swigt__p_SubnetTree, - &_swigt__p__inx_addr, - &_swigt__p_char, - &_swigt__p_in6_addr, - &_swigt__p_in_addr, -}; + SWIGINTERN PyObject* _wrap_SubnetTree___delitem__(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* resultobj = 0; + SubnetTree* arg1 = (SubnetTree*)0; + char* arg2 = (char*)0; + void* argp1 = 0; + int res1 = 0; + int res2; + char* buf2 = 0; + int alloc2 = 0; + PyObject* obj0 = 0; + PyObject* obj1 = 0; + PyObject* result = 0; + + if ( ! PyArg_ParseTuple(args, (char*)"OO:SubnetTree___delitem__", &obj0, &obj1) ) + SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SubnetTree, 0 | 0); + if ( ! SWIG_IsOK(res1) ) { + SWIG_exception_fail(SWIG_ArgError(res1), + "in method '" + "SubnetTree___delitem__" + "', argument " + "1" + " of type '" + "SubnetTree *" + "'"); + } + arg1 = reinterpret_cast(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if ( ! SWIG_IsOK(res2) ) { + SWIG_exception_fail(SWIG_ArgError(res2), + "in method '" + "SubnetTree___delitem__" + "', argument " + "2" + " of type '" + "char const *" + "'"); + } + arg2 = reinterpret_cast(buf2); + result = (PyObject*)SubnetTree___delitem__(arg1, (char const*)arg2); + resultobj = result; + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return resultobj; + fail: + if ( alloc2 == SWIG_NEWOBJ ) + delete[] buf2; + return NULL; + } -static swig_cast_info _swigc__p_SubnetTree[] = { {&_swigt__p_SubnetTree, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p__inx_addr[] = { {&_swigt__p__inx_addr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_in6_addr[] = { {&_swigt__p_in6_addr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_in_addr[] = { {&_swigt__p_in_addr, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_SubnetTree, - _swigc__p__inx_addr, - _swigc__p_char, - _swigc__p_in6_addr, - _swigc__p_in_addr, -}; + SWIGINTERN PyObject* SubnetTree_swigregister(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* obj; + if ( ! PyArg_ParseTuple(args, (char*)"O:swigregister", &obj) ) + return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_SubnetTree, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); + } -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + SWIGINTERN PyObject* SubnetTree_swigregister(PyObject * SWIGUNUSEDPARM(self), PyObject * args) { + PyObject* obj; + if ( ! PyArg_ParseTuple(args, (char*)"O:swigregister", &obj) ) + return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_SubnetTree, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); + } -static swig_const_info swig_const_table[] = { -{0, 0, 0, 0.0, 0, 0}}; + static PyMethodDef SwigMethods[] = + {{(char*)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, + {(char*)"inx_addr_sin_set", _wrap_inx_addr_sin_set, METH_VARARGS, NULL}, + {(char*)"inx_addr_sin_get", _wrap_inx_addr_sin_get, METH_VARARGS, NULL}, + {(char*)"inx_addr_sin6_set", _wrap_inx_addr_sin6_set, METH_VARARGS, NULL}, + {(char*)"inx_addr_sin6_get", _wrap_inx_addr_sin6_get, METH_VARARGS, NULL}, + {(char*)"new_inx_addr", _wrap_new_inx_addr, METH_VARARGS, NULL}, + {(char*)"delete_inx_addr", _wrap_delete_inx_addr, METH_VARARGS, NULL}, + {(char*)"inx_addr_swigregister", inx_addr_swigregister, METH_VARARGS, NULL}, + {(char*)"new_SubnetTree", _wrap_new_SubnetTree, METH_VARARGS, NULL}, + {(char*)"delete_SubnetTree", _wrap_delete_SubnetTree, METH_VARARGS, NULL}, + {(char*)"SubnetTree_insert", _wrap_SubnetTree_insert, METH_VARARGS, NULL}, + {(char*)"SubnetTree_remove", _wrap_SubnetTree_remove, METH_VARARGS, NULL}, + {(char*)"SubnetTree_lookup", _wrap_SubnetTree_lookup, METH_VARARGS, NULL}, + {(char*)"SubnetTree_search_all", _wrap_SubnetTree_search_all, METH_VARARGS, NULL}, + {(char*)"SubnetTree_prefixes", _wrap_SubnetTree_prefixes, METH_VARARGS, NULL}, + {(char*)"SubnetTree_get_binary_lookup_mode", _wrap_SubnetTree_get_binary_lookup_mode, METH_VARARGS, + NULL}, + {(char*)"SubnetTree_set_binary_lookup_mode", _wrap_SubnetTree_set_binary_lookup_mode, METH_VARARGS, + NULL}, + {(char*)"SubnetTree___contains__", _wrap_SubnetTree___contains__, METH_VARARGS, NULL}, + {(char*)"SubnetTree___getitem__", _wrap_SubnetTree___getitem__, METH_VARARGS, NULL}, + {(char*)"SubnetTree___setitem__", _wrap_SubnetTree___setitem__, METH_VARARGS, NULL}, + {(char*)"SubnetTree___delitem__", _wrap_SubnetTree___delitem__, METH_VARARGS, NULL}, + {(char*)"SubnetTree_swigregister", SubnetTree_swigregister, METH_VARARGS, NULL}, + {NULL, NULL, 0, NULL}}; + + + /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + + static swig_type_info _swigt__p_SubnetTree = {"_p_SubnetTree", "SubnetTree *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p__inx_addr = {"_p__inx_addr", "_inx_addr *|inx_addr *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_in6_addr = {"_p_in6_addr", "in6_addr *", 0, 0, (void*)0, 0}; + static swig_type_info _swigt__p_in_addr = {"_p_in_addr", "in_addr *", 0, 0, (void*)0, 0}; + + static swig_type_info* swig_type_initial[] = { + &_swigt__p_SubnetTree, &_swigt__p__inx_addr, &_swigt__p_char, &_swigt__p_in6_addr, &_swigt__p_in_addr, + }; + + static swig_cast_info _swigc__p_SubnetTree[] = {{&_swigt__p_SubnetTree, 0, 0, 0}, {0, 0, 0, 0}}; + static swig_cast_info _swigc__p__inx_addr[] = {{&_swigt__p__inx_addr, 0, 0, 0}, {0, 0, 0, 0}}; + static swig_cast_info _swigc__p_char[] = {{&_swigt__p_char, 0, 0, 0}, {0, 0, 0, 0}}; + static swig_cast_info _swigc__p_in6_addr[] = {{&_swigt__p_in6_addr, 0, 0, 0}, {0, 0, 0, 0}}; + static swig_cast_info _swigc__p_in_addr[] = {{&_swigt__p_in_addr, 0, 0, 0}, {0, 0, 0, 0}}; + + static swig_cast_info* swig_cast_initial[] = { + _swigc__p_SubnetTree, _swigc__p__inx_addr, _swigc__p_char, _swigc__p_in6_addr, _swigc__p_in_addr, + }; + + + /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + + static swig_const_info swig_const_table[] = {{0, 0, 0, 0.0, 0, 0}}; #ifdef __cplusplus -} + } #endif -/* ----------------------------------------------------------------------------- - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - * - * The generated swig_type_info structures are assigned statically to an initial - * array. We just loop through that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - * - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. - * ----------------------------------------------------------------------------- */ + /* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ #ifdef __cplusplus -extern "C" { + extern "C" { #if 0 } /* c-mode */ #endif @@ -5125,635 +5771,632 @@ extern "C" { #endif -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - size_t i; - swig_module_info *module_head, *iter; - int init; - - /* check to see if the circular list has been setup, if not, set it up */ - if (swig_module.next==0) { - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - swig_module.next = &swig_module; - init = 1; - } else { - init = 0; - } - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (!module_head) { - /* This is the first module loaded for this interpreter */ - /* so set the swig module into the interpreter */ - SWIG_SetModule(clientdata, &swig_module); - } else { - /* the interpreter has loaded a SWIG module, but has it loaded this one? */ - iter=module_head; - do { - if (iter==&swig_module) { - /* Our module is already in the list, so there's nothing more to do. */ - return; - } - iter=iter->next; - } while (iter!= module_head); + SWIGRUNTIME void SWIG_InitializeModule(void* clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if ( swig_module.next == 0 ) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } + else { + init = 0; + } - /* otherwise we must add our module into the list */ - swig_module.next = module_head->next; - module_head->next = &swig_module; - } + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if ( ! module_head ) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } + else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter = module_head; + do { + if ( iter == &swig_module ) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter = iter->next; + } while ( iter != module_head ); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } - /* When multiple interpreters are used, a module could have already been initialized in - a different interpreter, but not yet have a pointer in this interpreter. - In this case, we do not want to continue adding types... everything should be - set up already */ - if (init == 0) return; + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if ( init == 0 ) + return; - /* Now work on filling in swig_module.types */ + /* Now work on filling in swig_module.types */ #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); + printf("SWIG_InitializeModule: size %d\n", swig_module.size); #endif - for (i = 0; i < swig_module.size; ++i) { - swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; + for ( i = 0; i < swig_module.size; ++i ) { + swig_type_info* type = 0; + swig_type_info* ret; + swig_cast_info* cast; #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); #endif - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ + /* if there is another module already loaded */ + if ( swig_module.next != &swig_module ) { + type = + SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if ( type ) { + /* Overwrite clientdata field */ #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found type %s\n", type->name); + printf("SWIG_InitializeModule: found type %s\n", type->name); #endif - if (swig_module.type_initial[i]->clientdata) { - type->clientdata = swig_module.type_initial[i]->clientdata; + if ( swig_module.type_initial[i]->clientdata ) { + type->clientdata = swig_module.type_initial[i]->clientdata; #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); #endif - } - } else { - type = swig_module.type_initial[i]; - } + } + } + else { + type = swig_module.type_initial[i]; + } - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - /* Don't need to add information already in the list */ - ret = 0; + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while ( cast->type ) { + /* Don't need to add information already in the list */ + ret = 0; #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); #endif - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); + if ( swig_module.next != &swig_module ) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); #ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); + if ( ret ) + printf("SWIG_InitializeModule: found cast %s\n", ret->name); #endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { + } + if ( ret ) { + if ( type == swig_module.type_initial[i] ) { #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); -#endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } + else { + /* Check for casting already in the list */ + swig_cast_info* ocast = SWIG_TypeCheck(ret->name, type); #ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); + if ( ocast ) + printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); #endif - if (!ocast) ret = 0; - } - } + if ( ! ocast ) + ret = 0; + } + } - if (!ret) { + if ( ! ret ) { #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); -#endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - cast++; - } - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if ( type->cast ) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; #ifdef SWIGRUNTIME_DEBUG - printf("**** SWIG_InitializeModule: Cast List ******\n"); - for (i = 0; i < swig_module.size; ++i) { - int j = 0; - swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); - while (cast->type) { - printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); - cast++; - ++j; - } - printf("---- Total casts: %d\n",j); - } - printf("**** SWIG_InitializeModule: Cast List ******\n"); + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for ( i = 0; i < swig_module.size; ++i ) { + int j = 0; + swig_cast_info* cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while ( cast->type ) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n", j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); #endif -} + } -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} + /* This function will propagate the clientdata field of type to + * any new swig_type_info structures that have been added into the list + * of equivalent types. It is like calling + * SWIG_TypeClientData(type, clientdata) a second time. + */ + SWIGRUNTIME void SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info* equiv; + static int init_run = 0; + + if ( init_run ) + return; + init_run = 1; + + for ( i = 0; i < swig_module.size; i++ ) { + if ( swig_module.types[i]->clientdata ) { + equiv = swig_module.types[i]->cast; + while ( equiv ) { + if ( ! equiv->converter ) { + if ( equiv->type && ! equiv->type->clientdata ) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } + } #ifdef __cplusplus #if 0 { /* c-mode */ #endif -} + } #endif - #ifdef __cplusplus -extern "C" { + extern "C" { #endif - /* Python-specific SWIG API */ -#define SWIG_newvarlink() SWIG_Python_newvarlink() -#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) -#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) +/* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) - /* ----------------------------------------------------------------------------- - * global variable support code. - * ----------------------------------------------------------------------------- */ + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ - typedef struct swig_globalvar { - char *name; /* Name of global variable */ - PyObject *(*get_attr)(void); /* Return the current value */ - int (*set_attr)(PyObject *); /* Set the value */ - struct swig_globalvar *next; - } swig_globalvar; + typedef struct swig_globalvar { + char* name; /* Name of global variable */ + PyObject* (*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject*); /* Set the value */ + struct swig_globalvar* next; + } swig_globalvar; - typedef struct swig_varlinkobject { - PyObject_HEAD - swig_globalvar *vars; - } swig_varlinkobject; + typedef struct swig_varlinkobject { + PyObject_HEAD swig_globalvar* vars; + } swig_varlinkobject; - SWIGINTERN PyObject * - swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { + SWIGINTERN PyObject* swig_varlink_repr(swig_varlinkobject* SWIGUNUSEDPARM(v)) { #if PY_VERSION_HEX >= 0x03000000 - return PyUnicode_InternFromString(""); + return PyUnicode_InternFromString(""); #else - return PyString_FromString(""); + return PyString_FromString(""); #endif - } + } - SWIGINTERN PyObject * - swig_varlink_str(swig_varlinkobject *v) { + SWIGINTERN PyObject* swig_varlink_str(swig_varlinkobject* v) { #if PY_VERSION_HEX >= 0x03000000 - PyObject *str = PyUnicode_InternFromString("("); - PyObject *tail; - PyObject *joined; - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - tail = PyUnicode_FromString(var->name); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - if (var->next) { - tail = PyUnicode_InternFromString(", "); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; - } - } - tail = PyUnicode_InternFromString(")"); - joined = PyUnicode_Concat(str, tail); - Py_DecRef(str); - Py_DecRef(tail); - str = joined; + PyObject* str = PyUnicode_InternFromString("("); + PyObject* tail; + PyObject* joined; + swig_globalvar* var; + for ( var = v->vars; var; var = var->next ) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if ( var->next ) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; #else - PyObject *str = PyString_FromString("("); - swig_globalvar *var; - for (var = v->vars; var; var=var->next) { - PyString_ConcatAndDel(&str,PyString_FromString(var->name)); - if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); - } - PyString_ConcatAndDel(&str,PyString_FromString(")")); -#endif - return str; - } - - SWIGINTERN int - swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { - char *tmp; - PyObject *str = swig_varlink_str(v); - fprintf(fp,"Swig global variables "); - fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(str); - return 0; - } - - SWIGINTERN void - swig_varlink_dealloc(swig_varlinkobject *v) { - swig_globalvar *var = v->vars; - while (var) { - swig_globalvar *n = var->next; - free(var->name); - free(var); - var = n; - } - } - - SWIGINTERN PyObject * - swig_varlink_getattr(swig_varlinkobject *v, char *n) { - PyObject *res = NULL; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->get_attr)(); - break; - } - var = var->next; - } - if (res == NULL && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } - - SWIGINTERN int - swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { - int res = 1; - swig_globalvar *var = v->vars; - while (var) { - if (strcmp(var->name,n) == 0) { - res = (*var->set_attr)(p); - break; - } - var = var->next; - } - if (res == 1 && !PyErr_Occurred()) { - PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); - } - return res; - } + PyObject* str = PyString_FromString("("); + swig_globalvar* var; + for ( var = v->vars; var; var = var->next ) { + PyString_ConcatAndDel(&str, PyString_FromString(var->name)); + if ( var->next ) + PyString_ConcatAndDel(&str, PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str, PyString_FromString(")")); +#endif + return str; + } - SWIGINTERN PyTypeObject* - swig_varlink_type(void) { - static char varlink__doc__[] = "Swig var link object"; - static PyTypeObject varlink_type; - static int type_init = 0; - if (!type_init) { - const PyTypeObject tmp = { + SWIGINTERN int swig_varlink_print(swig_varlinkobject* v, FILE* fp, int SWIGUNUSEDPARM(flags)) { + char* tmp; + PyObject* str = swig_varlink_str(v); + fprintf(fp, "Swig global variables "); + fprintf(fp, "%s\n", tmp = SWIG_Python_str_AsChar(str)); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(str); + return 0; + } + + SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject* v) { + swig_globalvar* var = v->vars; + while ( var ) { + swig_globalvar* n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject* swig_varlink_getattr(swig_varlinkobject* v, char* n) { + PyObject* res = NULL; + swig_globalvar* var = v->vars; + while ( var ) { + if ( strcmp(var->name, n) == 0 ) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if ( res == NULL && ! PyErr_Occurred() ) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int swig_varlink_setattr(swig_varlinkobject* v, char* n, PyObject* p) { + int res = 1; + swig_globalvar* var = v->vars; + while ( var ) { + if ( strcmp(var->name, n) == 0 ) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if ( res == 1 && ! PyErr_Occurred() ) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if ( ! type_init ) { + const PyTypeObject tmp = { #if PY_VERSION_HEX >= 0x03000000 - PyVarObject_HEAD_INIT(NULL, 0) + PyVarObject_HEAD_INIT(NULL, 0) #else - PyObject_HEAD_INIT(NULL) - 0, /* ob_size */ -#endif - (char *)"swigvarlink", /* tp_name */ - sizeof(swig_varlinkobject), /* tp_basicsize */ - 0, /* tp_itemsize */ - (destructor) swig_varlink_dealloc, /* tp_dealloc */ - (printfunc) swig_varlink_print, /* tp_print */ - (getattrfunc) swig_varlink_getattr, /* tp_getattr */ - (setattrfunc) swig_varlink_setattr, /* tp_setattr */ - 0, /* tp_compare */ - (reprfunc) swig_varlink_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - (reprfunc) swig_varlink_str, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - 0, /* tp_flags */ - varlink__doc__, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ + PyObject_HEAD_INIT(NULL) 0, /* ob_size */ +#endif + (char*) "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)swig_varlink_dealloc, /* tp_dealloc */ + (printfunc)swig_varlink_print, /* tp_print */ + (getattrfunc)swig_varlink_getattr, /* tp_getattr */ + (setattrfunc)swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc)swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ #if PY_VERSION_HEX >= 0x02020000 - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, /* tp_iter -> tp_weaklist */ #endif #if PY_VERSION_HEX >= 0x02030000 - 0, /* tp_del */ + 0, /* tp_del */ #endif #if PY_VERSION_HEX >= 0x02060000 - 0, /* tp_version_tag */ + 0, /* tp_version_tag */ #endif #if PY_VERSION_HEX >= 0x03040000 - 0, /* tp_finalize */ + 0, /* tp_finalize */ #endif #ifdef COUNT_ALLOCS - 0, /* tp_allocs */ - 0, /* tp_frees */ - 0, /* tp_maxalloc */ + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ #if PY_VERSION_HEX >= 0x02050000 - 0, /* tp_prev */ + 0, /* tp_prev */ #endif - 0 /* tp_next */ + 0 /* tp_next */ #endif - }; - varlink_type = tmp; - type_init = 1; + }; + varlink_type = tmp; + type_init = 1; #if PY_VERSION_HEX < 0x02020000 - varlink_type.ob_type = &PyType_Type; + varlink_type.ob_type = &PyType_Type; #else - if (PyType_Ready(&varlink_type) < 0) - return NULL; -#endif - } - return &varlink_type; - } - - /* Create a variable linking object for use later */ - SWIGINTERN PyObject * - SWIG_Python_newvarlink(void) { - swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); - if (result) { - result->vars = 0; - } - return ((PyObject*) result); - } - - SWIGINTERN void - SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { - swig_varlinkobject *v = (swig_varlinkobject *) p; - swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); - if (gv) { - size_t size = strlen(name)+1; - gv->name = (char *)malloc(size); - if (gv->name) { - strncpy(gv->name,name,size); - gv->get_attr = get_attr; - gv->set_attr = set_attr; - gv->next = v->vars; - } - } - v->vars = gv; - } - - SWIGINTERN PyObject * - SWIG_globals(void) { - static PyObject *_SWIG_globals = 0; - if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); - return _SWIG_globals; - } + if ( PyType_Ready(&varlink_type) < 0 ) + return NULL; +#endif + } + return &varlink_type; + } - /* ----------------------------------------------------------------------------- - * constants/methods manipulation - * ----------------------------------------------------------------------------- */ + /* Create a variable linking object for use later */ + SWIGINTERN PyObject* SWIG_Python_newvarlink(void) { + swig_varlinkobject* result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if ( result ) { + result->vars = 0; + } + return ((PyObject*)result); + } - /* Install Constants */ - SWIGINTERN void - SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { - PyObject *obj = 0; - size_t i; - for (i = 0; constants[i].type; ++i) { - switch(constants[i].type) { - case SWIG_PY_POINTER: - obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); - break; - case SWIG_PY_BINARY: - obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); - break; - default: - obj = 0; - break; - } - if (obj) { - PyDict_SetItemString(d, constants[i].name, obj); - Py_DECREF(obj); - } - } - } + SWIGINTERN void SWIG_Python_addvarlink(PyObject* p, char* name, PyObject* (*get_attr)(void), + int (*set_attr)(PyObject* p)) { + swig_varlinkobject* v = (swig_varlinkobject*)p; + swig_globalvar* gv = (swig_globalvar*)malloc(sizeof(swig_globalvar)); + if ( gv ) { + size_t size = strlen(name) + 1; + gv->name = (char*)malloc(size); + if ( gv->name ) { + strncpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } - /* -----------------------------------------------------------------------------*/ - /* Fix SwigMethods to carry the callback ptrs when needed */ - /* -----------------------------------------------------------------------------*/ + SWIGINTERN PyObject* SWIG_globals(void) { + static PyObject* _SWIG_globals = 0; + if ( ! _SWIG_globals ) + _SWIG_globals = SWIG_newvarlink(); + return _SWIG_globals; + } - SWIGINTERN void - SWIG_Python_FixMethods(PyMethodDef *methods, - swig_const_info *const_table, - swig_type_info **types, - swig_type_info **types_initial) { - size_t i; - for (i = 0; methods[i].ml_name; ++i) { - const char *c = methods[i].ml_doc; - if (!c) continue; - c = strstr(c, "swig_ptr: "); - if (c) { - int j; - swig_const_info *ci = 0; - const char *name = c + 10; - for (j = 0; const_table[j].type; ++j) { - if (strncmp(const_table[j].name, name, - strlen(const_table[j].name)) == 0) { - ci = &(const_table[j]); - break; - } + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void SWIG_Python_InstallConstants(PyObject* d, swig_const_info constants[]) { + PyObject* obj = 0; + size_t i; + for ( i = 0; constants[i].type; ++i ) { + switch ( constants[i].type ) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype, 0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: obj = 0; break; + } + if ( obj ) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } } - if (ci) { - void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; - if (ptr) { - size_t shift = (ci->ptype) - types; - swig_type_info *ty = types_initial[shift]; - size_t ldoc = (c - methods[i].ml_doc); - size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; - char *ndoc = (char*)malloc(ldoc + lptr + 10); - if (ndoc) { - char *buff = ndoc; - strncpy(buff, methods[i].ml_doc, ldoc); - buff += ldoc; - strncpy(buff, "swig_ptr: ", 10); - buff += 10; - SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); - methods[i].ml_doc = ndoc; + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef* methods, swig_const_info* const_table, + swig_type_info** types, swig_type_info** types_initial) { + size_t i; + for ( i = 0; methods[i].ml_name; ++i ) { + const char* c = methods[i].ml_doc; + if ( ! c ) + continue; + c = strstr(c, "swig_ptr: "); + if ( c ) { + int j; + swig_const_info* ci = 0; + const char* name = c + 10; + for ( j = 0; const_table[j].type; ++j ) { + if ( strncmp(const_table[j].name, name, strlen(const_table[j].name)) == 0 ) { + ci = &(const_table[j]); + break; + } + } + if ( ci ) { + void* ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if ( ptr ) { + size_t shift = (ci->ptype) - types; + swig_type_info* ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name) + 2 * sizeof(void*) + 2; + char* ndoc = (char*)malloc(ldoc + lptr + 10); + if ( ndoc ) { + char* buff = ndoc; + strncpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + strncpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } } - } } - } - } - } #ifdef __cplusplus -} + } #endif -/* -----------------------------------------------------------------------------* - * Partial Init method - * -----------------------------------------------------------------------------*/ + /* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ #ifdef __cplusplus -extern "C" + extern "C" #endif -SWIGEXPORT + SWIGEXPORT #if PY_VERSION_HEX >= 0x03000000 -PyObject* + PyObject* #else -void + void #endif -SWIG_init(void) { - PyObject *m, *d, *md; + SWIG_init(void) { + PyObject *m, *d, *md; #if PY_VERSION_HEX >= 0x03000000 - static struct PyModuleDef SWIG_module = { -# if PY_VERSION_HEX >= 0x03020000 - PyModuleDef_HEAD_INIT, -# else + static struct PyModuleDef SWIG_module = { +#if PY_VERSION_HEX >= 0x03020000 + PyModuleDef_HEAD_INIT, +#else { PyObject_HEAD_INIT(NULL) NULL, /* m_init */ 0, /* m_index */ NULL, /* m_copy */ }, -# endif - (char *) SWIG_name, - NULL, - -1, - SwigMethods, - NULL, - NULL, - NULL, - NULL - }; +#endif + (char*)SWIG_name, NULL, -1, SwigMethods, NULL, NULL, NULL, NULL}; #endif #if defined(SWIGPYTHON_BUILTIN) - static SwigPyClientData SwigPyObject_clientdata = { - 0, 0, 0, 0, 0, 0, 0 - }; - static PyGetSetDef this_getset_def = { - (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL - }; - static SwigPyGetSet thisown_getset_closure = { - (PyCFunction) SwigPyObject_own, - (PyCFunction) SwigPyObject_own - }; - static PyGetSetDef thisown_getset_def = { - (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure - }; - PyTypeObject *builtin_pytype; - int builtin_base_count; - swig_type_info *builtin_basetype; - PyObject *tuple; - PyGetSetDescrObject *static_getset; - PyTypeObject *metatype; - PyTypeObject *swigpyobject; - SwigPyClientData *cd; - PyObject *public_interface, *public_symbol; - PyObject *this_descr; - PyObject *thisown_descr; - PyObject *self = 0; - int i; - - (void)builtin_pytype; - (void)builtin_base_count; - (void)builtin_basetype; - (void)tuple; - (void)static_getset; - (void)self; - - /* Metaclass is used to implement static member variables */ - metatype = SwigPyObjectType(); - assert(metatype); -#endif - - /* Fix SwigMethods to carry the callback ptrs when needed */ - SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + static SwigPyClientData SwigPyObject_clientdata = {0, 0, 0, 0, 0, 0, 0}; + static PyGetSetDef this_getset_def = {(char*)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL}; + static SwigPyGetSet thisown_getset_closure = {(PyCFunction)SwigPyObject_own, (PyCFunction)SwigPyObject_own}; + static PyGetSetDef thisown_getset_def = {(char*)"thisown", SwigPyBuiltin_GetterClosure, + SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure}; + PyTypeObject* builtin_pytype; + int builtin_base_count; + swig_type_info* builtin_basetype; + PyObject* tuple; + PyGetSetDescrObject* static_getset; + PyTypeObject* metatype; + PyTypeObject* swigpyobject; + SwigPyClientData* cd; + PyObject *public_interface, *public_symbol; + PyObject* this_descr; + PyObject* thisown_descr; + PyObject* self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); #if PY_VERSION_HEX >= 0x03000000 - m = PyModule_Create(&SWIG_module); + m = PyModule_Create(&SWIG_module); #else - m = Py_InitModule((char *) SWIG_name, SwigMethods); + m = Py_InitModule((char*)SWIG_name, SwigMethods); #endif - md = d = PyModule_GetDict(m); - (void)md; + md = d = PyModule_GetDict(m); + (void)md; - SWIG_InitializeModule(0); + SWIG_InitializeModule(0); #ifdef SWIGPYTHON_BUILTIN - swigpyobject = SwigPyObject_TypeOnce(); - - SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); - assert(SwigPyObject_stype); - cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; - if (!cd) { - SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; - SwigPyObject_clientdata.pytype = swigpyobject; - } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { - PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); -# if PY_VERSION_HEX >= 0x03000000 - return NULL; -# else - return; -# endif - } + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*)SwigPyObject_stype->clientdata; + if ( ! cd ) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } + else if ( swigpyobject->tp_basicsize != cd->pytype->tp_basicsize ) { + PyErr_SetString(PyExc_RuntimeError, + "Import error: attempted to load two incompatible swig-generated modules."); +#if PY_VERSION_HEX >= 0x03000000 + return NULL; +#else + return; +#endif + } - /* All objects have a 'this' attribute */ - this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); - (void)this_descr; + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; - /* All objects have a 'thisown' attribute */ - thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); - (void)thisown_descr; + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; - public_interface = PyList_New(0); - public_symbol = 0; - (void)public_symbol; + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; - PyDict_SetItemString(md, "__all__", public_interface); - Py_DECREF(public_interface); - for (i = 0; SwigMethods[i].ml_name != NULL; ++i) - SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); - for (i = 0; swig_const_table[i].name != 0; ++i) - SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for ( i = 0; SwigMethods[i].ml_name != NULL; ++i ) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for ( i = 0; swig_const_table[i].name != 0; ++i ) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); #endif - SWIG_InstallConstants(d,swig_const_table); + SWIG_InstallConstants(d, swig_const_table); #if PY_VERSION_HEX >= 0x03000000 - return m; + return m; #else - return; + return; #endif -} + } diff --git a/include/SubnetTree.h b/include/SubnetTree.h index 744a4cc..1d4922e 100644 --- a/include/SubnetTree.h +++ b/include/SubnetTree.h @@ -69,130 +69,124 @@ extern "C" { #endif typedef union _inx_addr { - struct in_addr sin; - struct in6_addr sin6; + struct in_addr sin; + struct in6_addr sin6; } inx_addr; -class SubnetTree -{ +class SubnetTree { public: - SubnetTree(bool binary_lookup_mode = false); - ~SubnetTree(); + SubnetTree(bool binary_lookup_mode = false); + ~SubnetTree(); - PyObject* insert(const char *cidr, PyObject* data = 0); - PyObject* insert(unsigned long subnet, unsigned short mask, PyObject* data = 0); + PyObject* insert(const char* cidr, PyObject* data = 0); + PyObject* insert(unsigned long subnet, unsigned short mask, PyObject* data = 0); - PyObject* remove(const char *cidr); - PyObject* remove(unsigned long subnet, unsigned short mask); + PyObject* remove(const char* cidr); + PyObject* remove(unsigned long subnet, unsigned short mask); - PyObject* lookup(const char *cidr, int size) const; - PyObject* lookup(unsigned long addr) const; + PyObject* lookup(const char* cidr, int size) const; + PyObject* lookup(unsigned long addr) const; - PyObject* search_all(const char *cidr, int size) const; + PyObject* search_all(const char* cidr, int size) const; - PyObject* prefixes(bool ipv4_native = false, bool with_len = true) const; + PyObject* prefixes(bool ipv4_native = false, bool with_len = true) const; - bool get_binary_lookup_mode(); - void set_binary_lookup_mode(bool binary_lookup_mode = true); + bool get_binary_lookup_mode(); + void set_binary_lookup_mode(bool binary_lookup_mode = true); #ifndef SWIG - bool operator[](const char* addr) const { return lookup(addr, strlen(addr)); } - bool operator[](unsigned long addr) const { return lookup(addr); } + bool operator[](const char* addr) const { return lookup(addr, strlen(addr)); } + bool operator[](unsigned long addr) const { return lookup(addr); } #else - %extend { - PyObject* __contains__(const char *cidr, int size) - { - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - PyObject* obj = self->lookup(cidr, size); - if ( obj ) - { - Py_DECREF(obj); - } - - if ( PyErr_Occurred() ) - return 0; - - if ( obj != 0 ) - Py_RETURN_TRUE; - else - Py_RETURN_FALSE; - } - - PyObject* __contains__(unsigned long addr) - { - PyObject* obj = self->lookup(addr); - - if ( obj ) - { - Py_DECREF(obj); - } - - if ( PyErr_Occurred() ) - return 0; - - if ( obj != 0 ) - Py_RETURN_TRUE; - else - Py_RETURN_FALSE; - } - - PyObject* __getitem__(const char *cidr, int size) - { - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - PyObject* data = self->lookup(cidr, size); - if ( ! data ) { - PyErr_SetObject(PyExc_KeyError, PyBytes_FromStringAndSize(cidr, size)); - return 0; - } - - return data; - } - - PyObject* __setitem__(const char* cidr, PyObject* data) - { - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - if ( self->insert(cidr, data) ) - Py_RETURN_TRUE; - else - return 0; - } - - PyObject* __delitem__(const char* cidr) - { - if ( ! cidr ) { - PyErr_SetString(PyExc_TypeError, "index must be string"); - return 0; - } - - if ( self->remove(cidr) ) - Py_RETURN_TRUE; - else - return 0; - } - - } + // clang-format wants to insert a space after the % on the next line, which breaks + // SWIG's parsing of it. + // clang-format off + %extend { + // clang-format on + PyObject* __contains__(const char* cidr, int size) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + + PyObject* obj = self->lookup(cidr, size); + if ( obj ) { + Py_DECREF(obj); + } + + if ( PyErr_Occurred() ) + return 0; + + if ( obj != 0 ) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + + PyObject* __contains__(unsigned long addr) { + PyObject* obj = self->lookup(addr); + + if ( obj ) { + Py_DECREF(obj); + } + + if ( PyErr_Occurred() ) + return 0; + + if ( obj != 0 ) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + + PyObject* __getitem__(const char* cidr, int size) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + + PyObject* data = self->lookup(cidr, size); + if ( ! data ) { + PyErr_SetObject(PyExc_KeyError, PyBytes_FromStringAndSize(cidr, size)); + return 0; + } + + return data; + } + + PyObject* __setitem__(const char* cidr, PyObject* data) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + + if ( self->insert(cidr, data) ) + Py_RETURN_TRUE; + else + return 0; + } + + PyObject* __delitem__(const char* cidr) { + if ( ! cidr ) { + PyErr_SetString(PyExc_TypeError, "index must be string"); + return 0; + } + + if ( self->remove(cidr) ) + Py_RETURN_TRUE; + else + return 0; + } + } #endif private: + PyObject* insert(int family, inx_addr subnet, unsigned short mask, PyObject* data); + PyObject* remove(int family, inx_addr subnet, unsigned short mask); + PyObject* lookup(int family, inx_addr subnet) const; - PyObject* insert(int family, inx_addr subnet, unsigned short mask, PyObject * data); - PyObject* remove(int family, inx_addr subnet, unsigned short mask); - PyObject* lookup(int family, inx_addr subnet) const; + static void PatriciaDeleteFunction(void* data); - static void PatriciaDeleteFunction(void* data); - - patricia_tree_t* tree; - bool binary_lookup_mode; + patricia_tree_t* tree; + bool binary_lookup_mode; };