From 369f62ea190a3d869e996c3196fc33b4f19deb2b Mon Sep 17 00:00:00 2001 From: "Ken Leiter (Civ ARL/CISD) kleiter" Date: Fri, 9 Apr 2010 11:37:17 -0400 Subject: [PATCH] ENH: Add XdmfArray to store values --- modify XdmfDataItem to contain an XdmfArray. Modify Tests to use new XdmfArray. Modify XdmfVisitor to use new XdmfArray. Add Python Tests and move Cxx tests to their own directory. --- CMake/UsePythonTest.cmake | 52 + CMakeLists.txt | 7 +- Xdmf.i | 27 +- Xdmf.py | 608 +- XdmfArray.cpp | 288 + XdmfArray.hpp | 165 + XdmfAttribute.cpp | 5 - XdmfAttribute.hpp | 8 +- XdmfDataItem.cpp | 126 +- XdmfDataItem.hpp | 47 +- XdmfDataItemType.cpp | 108 - XdmfDataItemType.hpp | 86 - XdmfGeometry.cpp | 7 - XdmfGeometry.hpp | 2 - XdmfGrid.cpp | 6 +- XdmfGrid.hpp | 1 - XdmfPython.cpp | 32423 +++++++++++++++++++++--- XdmfTopology.cpp | 10 +- XdmfTopology.hpp | 7 - XdmfVisitor.cpp | 40 +- XdmfVisitor.hpp | 6 +- test.cpp | 29 - tests/CMakeLists.txt | 17 +- tests/Cxx/CMakeLists.txt | 15 + tests/Cxx/TestXdmfArray.cpp | 55 + tests/{ => Cxx}/TestXdmfAttribute.cpp | 0 tests/{ => Cxx}/TestXdmfDataItem.cpp | 0 tests/{ => Cxx}/TestXdmfGeometry.cpp | 0 tests/{ => Cxx}/TestXdmfGrid.cpp | 0 tests/{ => Cxx}/TestXdmfTopology.cpp | 0 tests/{ => Cxx}/TestXdmfVisitor.cpp | 14 +- tests/Python/CMakeLists.txt | 11 + tests/Python/TestXdmfArray.py | 13 + tests/Python/TestXdmfVisitor.py | 39 + 34 files changed, 29611 insertions(+), 4611 deletions(-) create mode 100644 CMake/UsePythonTest.cmake create mode 100644 XdmfArray.cpp create mode 100644 XdmfArray.hpp delete mode 100644 XdmfDataItemType.cpp delete mode 100644 XdmfDataItemType.hpp delete mode 100644 test.cpp create mode 100644 tests/Cxx/CMakeLists.txt create mode 100644 tests/Cxx/TestXdmfArray.cpp rename tests/{ => Cxx}/TestXdmfAttribute.cpp (100%) rename tests/{ => Cxx}/TestXdmfDataItem.cpp (100%) rename tests/{ => Cxx}/TestXdmfGeometry.cpp (100%) rename tests/{ => Cxx}/TestXdmfGrid.cpp (100%) rename tests/{ => Cxx}/TestXdmfTopology.cpp (100%) rename tests/{ => Cxx}/TestXdmfVisitor.cpp (82%) create mode 100644 tests/Python/CMakeLists.txt create mode 100644 tests/Python/TestXdmfArray.py create mode 100644 tests/Python/TestXdmfVisitor.py diff --git a/CMake/UsePythonTest.cmake b/CMake/UsePythonTest.cmake new file mode 100644 index 00000000..54263853 --- /dev/null +++ b/CMake/UsePythonTest.cmake @@ -0,0 +1,52 @@ +# Add a python test from a python file +# One cannot simply do: +# SET(ENV{PYTHONPATH} ${LIBRARY_OUTPUT_PATH}) +# SET(my_test "from test_mymodule import *\;test_mymodule()") +# ADD_TEST(PYTHON-TEST-MYMODULE python -c ${my_test}) +# Since cmake is only transmitting the ADD_TEST line to ctest thus you are loosing +# the env var. The only way to store the env var is to physically write in the cmake script +# whatever PYTHONPATH you want and then add the test as 'cmake -P python_test.cmake' +# +# Usage: +# SET_SOURCE_FILES_PROPERTIES(test.py PROPERTIES PYTHONPATH +# "${LIBRARY_OUTPUT_PATH}:${VTK_DIR}") +# ADD_PYTHON_TEST(PYTHON-TEST test.py) + +# Need python interpreter: +FIND_PACKAGE(PythonInterp REQUIRED) + +MACRO(ADD_PYTHON_TEST TESTNAME FILENAME) + GET_SOURCE_FILE_PROPERTY(loc ${FILENAME} LOCATION) + GET_SOURCE_FILE_PROPERTY(pyenv ${FILENAME} PYTHONPATH) + STRING(REGEX REPLACE ";" " " wo_semicolumn "${ARGN}") + FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME}.cmake +" + SET(ENV{PYTHONPATH} ${pyenv}) + EXECUTE_PROCESS( + COMMAND ${PYTHON_EXECUTABLE} ${loc} ${wo_semicolumn} + #WORKING_DIRECTORY @LIBRARY_OUTPUT_PATH@ + RESULT_VARIABLE import_res + OUTPUT_VARIABLE import_output + ERROR_VARIABLE import_output + ) + + # Pass the output back to ctest + MESSAGE("\${import_output}") + IF(import_res) + MESSAGE(SEND_ERROR "\${import_res}") + ENDIF(import_res) +" +) + ADD_TEST(${TESTNAME} cmake -P ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME}.cmake) +ENDMACRO(ADD_PYTHON_TEST) + +# Byte compile recursively a directory (DIRNAME) +MACRO(ADD_PYTHON_COMPILEALL_TEST DIRNAME) + # First get the path: + GET_FILENAME_COMPONENT(temp_path "${PYTHON_LIBRARIES}" PATH) + # Find the python script: + GET_FILENAME_COMPONENT(PYTHON_COMPILE_ALL_PY "${temp_path}/../compileall.py" ABSOLUTE) + # add test, use DIRNAME to create uniq name for the test: + ADD_TEST(COMPILE_ALL-${DIRNAME} ${PYTHON_EXECUTABLE} "${PYTHON_COMPILE_ALL_PY}" -q ${DIRNAME}) +ENDMACRO(ADD_PYTHON_COMPILEALL_TEST) + diff --git a/CMakeLists.txt b/CMakeLists.txt index 87692c75..1c68ce6b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,7 @@ project(Xdmf2) cmake_minimum_required(VERSION 2.6) +set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMake ${CMAKE_MODULE_PATH}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) set(BUILD_SHARED_LIBS true) @@ -29,12 +30,12 @@ if(XDMF_WRAP_PYTHON) endif(XDMF_WRAP_PYTHON) set(XdmfSources + XdmfArray XdmfAttribute XdmfAttributeCenter XdmfAttributeType XdmfDataItem - XdmfDataItemType - XdmfDomain + XdmfDomain XdmfGeometry XdmfGeometryType XdmfGrid @@ -63,6 +64,4 @@ option(BUILD_TESTING OFF) if(BUILD_TESTING) enable_testing() add_subdirectory(tests) - add_executable(XdmfTest test.cpp) - target_link_libraries(XdmfTest Xdmf) endif(BUILD_TESTING) diff --git a/Xdmf.i b/Xdmf.i index b18b75fc..15e90dd7 100644 --- a/Xdmf.i +++ b/Xdmf.i @@ -15,6 +15,7 @@ namespace boost { } %template(XdmfAttributePtr) boost::shared_ptr; +%template(XdmfArrayPtr) boost::shared_ptr; %template(XdmfDataItemPtr) boost::shared_ptr; %template(XdmfDomainPtr) boost::shared_ptr; %template(XdmfGeometryPtr) boost::shared_ptr; @@ -26,11 +27,11 @@ namespace boost { %module Xdmf %{ + #include #include #include #include #include - #include #include #include #include @@ -48,14 +49,36 @@ namespace boost { %include XdmfVisitor.hpp %include XdmfDataItem.hpp -%include XdmfDataItemType.hpp %include XdmfAttribute.hpp %include XdmfAttributeCenter.hpp %include XdmfAttributeType.hpp +%include XdmfArray.hpp %include XdmfDomain.hpp %include XdmfGeometry.hpp %include XdmfGeometryType.hpp %include XdmfGrid.hpp %include XdmfTopology.hpp %include XdmfTopologyType.hpp + +%template(CharVector) std::vector; +%template(ShortVector) std::vector; +%template(IntVector) std::vector; +%template(LongVector) std::vector; +%template(FloatVector) std::vector; +%template(DoubleVector) std::vector; +%template(UCharVector) std::vector; +%template(UShortVector) std::vector; +%template(UIntVector) std::vector; + +%extend XdmfArray { + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; + %template(setValues) setValues; +}; diff --git a/Xdmf.py b/Xdmf.py index d2e4ae76..50a9f351 100644 --- a/Xdmf.py +++ b/Xdmf.py @@ -1,5 +1,5 @@ # This file was automatically generated by SWIG (http://www.swig.org). -# Version 1.3.40 +# Version 1.3.37 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. @@ -10,18 +10,12 @@ if version_info >= (2,6,0): def swig_import_helper(): from os.path import dirname import imp - fp = None try: fp, pathname, description = imp.find_module('_Xdmf', [dirname(__file__)]) - except ImportError: - import _Xdmf - return _Xdmf - if fp is not None: - try: - _mod = imp.load_module('_Xdmf', fp, pathname, description) - finally: - fp.close() - return _mod + _mod = imp.load_module('_Xdmf', fp, pathname, description) + finally: + if fp is not None: fp.close() + return _mod _Xdmf = swig_import_helper() del swig_import_helper else: @@ -71,7 +65,7 @@ class SwigPyIterator(_object): __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr __swig_destroy__ = _Xdmf.delete_SwigPyIterator __del__ = lambda self : None; @@ -119,11 +113,37 @@ class XdmfAttributePtr(_object): def getAttributeCenterAsString(self): return _Xdmf.XdmfAttributePtr_getAttributeCenterAsString(self) def write(self, *args): return _Xdmf.XdmfAttributePtr_write(self, *args) def printSelf(self): return _Xdmf.XdmfAttributePtr_printSelf(self) - def setNumberValues(self, *args): return _Xdmf.XdmfAttributePtr_setNumberValues(self, *args) - def getNumberValues(self): return _Xdmf.XdmfAttributePtr_getNumberValues(self) + def setArray(self, *args): return _Xdmf.XdmfAttributePtr_setArray(self, *args) + def getArray(self, *args): return _Xdmf.XdmfAttributePtr_getArray(self, *args) XdmfAttributePtr_swigregister = _Xdmf.XdmfAttributePtr_swigregister XdmfAttributePtr_swigregister(XdmfAttributePtr) +class XdmfArrayPtr(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfArrayPtr, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XdmfArrayPtr, name) + __repr__ = _swig_repr + def __deref__(self): return _Xdmf.XdmfArrayPtr___deref__(self) + def __init__(self): + this = _Xdmf.new_XdmfArrayPtr() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Xdmf.delete_XdmfArrayPtr + __del__ = lambda self : None; + def New(self): return _Xdmf.XdmfArrayPtr_New(self) + def getType(self): return _Xdmf.XdmfArrayPtr_getType(self) + def getHDF5Type(self): return _Xdmf.XdmfArrayPtr_getHDF5Type(self) + def getPrecision(self): return _Xdmf.XdmfArrayPtr_getPrecision(self) + def getSize(self): return _Xdmf.XdmfArrayPtr_getSize(self) + def getValues(self): return _Xdmf.XdmfArrayPtr_getValues(self) + def getValuesPointer(self): return _Xdmf.XdmfArrayPtr_getValuesPointer(self) + def printSelf(self): return _Xdmf.XdmfArrayPtr_printSelf(self) + def write(self, *args): return _Xdmf.XdmfArrayPtr_write(self, *args) + def setValues(self, *args): return _Xdmf.XdmfArrayPtr_setValues(self, *args) +XdmfArrayPtr_swigregister = _Xdmf.XdmfArrayPtr_swigregister +XdmfArrayPtr_swigregister(XdmfArrayPtr) + class XdmfDataItemPtr(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfDataItemPtr, name, value) @@ -137,8 +157,8 @@ class XdmfDataItemPtr(_object): except: self.this = this __swig_destroy__ = _Xdmf.delete_XdmfDataItemPtr __del__ = lambda self : None; - def New(self): return _Xdmf.XdmfDataItemPtr_New(self) - def getNumberValues(self): return _Xdmf.XdmfDataItemPtr_getNumberValues(self) + def setArray(self, *args): return _Xdmf.XdmfDataItemPtr_setArray(self, *args) + def getArray(self, *args): return _Xdmf.XdmfDataItemPtr_getArray(self, *args) def printSelf(self): return _Xdmf.XdmfDataItemPtr_printSelf(self) def write(self, *args): return _Xdmf.XdmfDataItemPtr_write(self, *args) XdmfDataItemPtr_swigregister = _Xdmf.XdmfDataItemPtr_swigregister @@ -184,10 +204,10 @@ class XdmfGeometryPtr(_object): def setGeometryType(self, *args): return _Xdmf.XdmfGeometryPtr_setGeometryType(self, *args) def getGeometryTypeAsString(self): return _Xdmf.XdmfGeometryPtr_getGeometryTypeAsString(self) def getDimensions(self): return _Xdmf.XdmfGeometryPtr_getDimensions(self) - def setNumberPoints(self, *args): return _Xdmf.XdmfGeometryPtr_setNumberPoints(self, *args) def printSelf(self): return _Xdmf.XdmfGeometryPtr_printSelf(self) def write(self, *args): return _Xdmf.XdmfGeometryPtr_write(self, *args) - def getNumberValues(self): return _Xdmf.XdmfGeometryPtr_getNumberValues(self) + def setArray(self, *args): return _Xdmf.XdmfGeometryPtr_setArray(self, *args) + def getArray(self, *args): return _Xdmf.XdmfGeometryPtr_getArray(self, *args) XdmfGeometryPtr_swigregister = _Xdmf.XdmfGeometryPtr_swigregister XdmfGeometryPtr_swigregister(XdmfGeometryPtr) @@ -271,12 +291,12 @@ class XdmfTopologyPtr(_object): def getTopologyType(self): return _Xdmf.XdmfTopologyPtr_getTopologyType(self) def setTopologyType(self, *args): return _Xdmf.XdmfTopologyPtr_setTopologyType(self, *args) def getNumberElements(self): return _Xdmf.XdmfTopologyPtr_getNumberElements(self) - def setNumberElements(self, *args): return _Xdmf.XdmfTopologyPtr_setNumberElements(self, *args) def getTopologyTypeAsString(self): return _Xdmf.XdmfTopologyPtr_getTopologyTypeAsString(self) def getNodesPerElement(self): return _Xdmf.XdmfTopologyPtr_getNodesPerElement(self) def printSelf(self): return _Xdmf.XdmfTopologyPtr_printSelf(self) def write(self, *args): return _Xdmf.XdmfTopologyPtr_write(self, *args) - def getNumberValues(self): return _Xdmf.XdmfTopologyPtr_getNumberValues(self) + def setArray(self, *args): return _Xdmf.XdmfTopologyPtr_setArray(self, *args) + def getArray(self, *args): return _Xdmf.XdmfTopologyPtr_getArray(self, *args) XdmfTopologyPtr_swigregister = _Xdmf.XdmfTopologyPtr_swigregister XdmfTopologyPtr_swigregister(XdmfTopologyPtr) @@ -296,6 +316,8 @@ class XdmfVisitorPtr(_object): def New(self): return _Xdmf.XdmfVisitorPtr_New(self) def visit(self, *args): return _Xdmf.XdmfVisitorPtr_visit(self, *args) def printSelf(self): return _Xdmf.XdmfVisitorPtr_printSelf(self) + def getLightDataLimit(self): return _Xdmf.XdmfVisitorPtr_getLightDataLimit(self) + def setLightDataLimit(self, *args): return _Xdmf.XdmfVisitorPtr_setLightDataLimit(self, *args) XdmfVisitorPtr_swigregister = _Xdmf.XdmfVisitorPtr_swigregister XdmfVisitorPtr_swigregister(XdmfVisitorPtr) @@ -304,7 +326,7 @@ class XdmfObject(_object): __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfObject, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XdmfObject, name) - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr def printSelf(self): return _Xdmf.XdmfObject_printSelf(self) XdmfObject_swigregister = _Xdmf.XdmfObject_swigregister @@ -317,7 +339,7 @@ class XdmfItem(XdmfObject): __swig_getmethods__ = {} for _s in [XdmfObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) __getattr__ = lambda self, name: _swig_getattr(self, XdmfItem, name) - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr def write(self, *args): return _Xdmf.XdmfItem_write(self, *args) XdmfItem_swigregister = _Xdmf.XdmfItem_swigregister @@ -336,6 +358,8 @@ class XdmfVisitor(XdmfObject): if _newclass:New = staticmethod(_Xdmf.XdmfVisitor_New) def visit(self, *args): return _Xdmf.XdmfVisitor_visit(self, *args) def printSelf(self): return _Xdmf.XdmfVisitor_printSelf(self) + def getLightDataLimit(self): return _Xdmf.XdmfVisitor_getLightDataLimit(self) + def setLightDataLimit(self, *args): return _Xdmf.XdmfVisitor_setLightDataLimit(self, *args) XdmfVisitor_swigregister = _Xdmf.XdmfVisitor_swigregister XdmfVisitor_swigregister(XdmfVisitor) @@ -352,96 +376,13 @@ class XdmfDataItem(XdmfItem): __getattr__ = lambda self, name: _swig_getattr(self, XdmfDataItem, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr - __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfDataItem_New - if _newclass:New = staticmethod(_Xdmf.XdmfDataItem_New) - def getNumberValues(self): return _Xdmf.XdmfDataItem_getNumberValues(self) + def setArray(self, *args): return _Xdmf.XdmfDataItem_setArray(self, *args) + def getArray(self, *args): return _Xdmf.XdmfDataItem_getArray(self, *args) def printSelf(self): return _Xdmf.XdmfDataItem_printSelf(self) def write(self, *args): return _Xdmf.XdmfDataItem_write(self, *args) XdmfDataItem_swigregister = _Xdmf.XdmfDataItem_swigregister XdmfDataItem_swigregister(XdmfDataItem) -def XdmfDataItem_New(): - return _Xdmf.XdmfDataItem_New() -XdmfDataItem_New = _Xdmf.XdmfDataItem_New - -class XdmfDataItemType(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfDataItemType, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, XdmfDataItemType, name) - __repr__ = _swig_repr - __swig_getmethods__["Unknown"] = lambda x: _Xdmf.XdmfDataItemType_Unknown - if _newclass:Unknown = staticmethod(_Xdmf.XdmfDataItemType_Unknown) - __swig_getmethods__["Int8"] = lambda x: _Xdmf.XdmfDataItemType_Int8 - if _newclass:Int8 = staticmethod(_Xdmf.XdmfDataItemType_Int8) - __swig_getmethods__["Int16"] = lambda x: _Xdmf.XdmfDataItemType_Int16 - if _newclass:Int16 = staticmethod(_Xdmf.XdmfDataItemType_Int16) - __swig_getmethods__["Int32"] = lambda x: _Xdmf.XdmfDataItemType_Int32 - if _newclass:Int32 = staticmethod(_Xdmf.XdmfDataItemType_Int32) - __swig_getmethods__["Int64"] = lambda x: _Xdmf.XdmfDataItemType_Int64 - if _newclass:Int64 = staticmethod(_Xdmf.XdmfDataItemType_Int64) - __swig_getmethods__["Float32"] = lambda x: _Xdmf.XdmfDataItemType_Float32 - if _newclass:Float32 = staticmethod(_Xdmf.XdmfDataItemType_Float32) - __swig_getmethods__["Float64"] = lambda x: _Xdmf.XdmfDataItemType_Float64 - if _newclass:Float64 = staticmethod(_Xdmf.XdmfDataItemType_Float64) - __swig_getmethods__["UInt8"] = lambda x: _Xdmf.XdmfDataItemType_UInt8 - if _newclass:UInt8 = staticmethod(_Xdmf.XdmfDataItemType_UInt8) - __swig_getmethods__["UInt16"] = lambda x: _Xdmf.XdmfDataItemType_UInt16 - if _newclass:UInt16 = staticmethod(_Xdmf.XdmfDataItemType_UInt16) - __swig_getmethods__["UInt32"] = lambda x: _Xdmf.XdmfDataItemType_UInt32 - if _newclass:UInt32 = staticmethod(_Xdmf.XdmfDataItemType_UInt32) - def getName(self): return _Xdmf.XdmfDataItemType_getName(self) - def __eq__(self, *args): return _Xdmf.XdmfDataItemType___eq__(self, *args) - def __ne__(self, *args): return _Xdmf.XdmfDataItemType___ne__(self, *args) - def __init__(self, *args): - this = _Xdmf.new_XdmfDataItemType(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _Xdmf.delete_XdmfDataItemType - __del__ = lambda self : None; -XdmfDataItemType_swigregister = _Xdmf.XdmfDataItemType_swigregister -XdmfDataItemType_swigregister(XdmfDataItemType) - -def XdmfDataItemType_Unknown(): - return _Xdmf.XdmfDataItemType_Unknown() -XdmfDataItemType_Unknown = _Xdmf.XdmfDataItemType_Unknown - -def XdmfDataItemType_Int8(): - return _Xdmf.XdmfDataItemType_Int8() -XdmfDataItemType_Int8 = _Xdmf.XdmfDataItemType_Int8 - -def XdmfDataItemType_Int16(): - return _Xdmf.XdmfDataItemType_Int16() -XdmfDataItemType_Int16 = _Xdmf.XdmfDataItemType_Int16 - -def XdmfDataItemType_Int32(): - return _Xdmf.XdmfDataItemType_Int32() -XdmfDataItemType_Int32 = _Xdmf.XdmfDataItemType_Int32 - -def XdmfDataItemType_Int64(): - return _Xdmf.XdmfDataItemType_Int64() -XdmfDataItemType_Int64 = _Xdmf.XdmfDataItemType_Int64 - -def XdmfDataItemType_Float32(): - return _Xdmf.XdmfDataItemType_Float32() -XdmfDataItemType_Float32 = _Xdmf.XdmfDataItemType_Float32 - -def XdmfDataItemType_Float64(): - return _Xdmf.XdmfDataItemType_Float64() -XdmfDataItemType_Float64 = _Xdmf.XdmfDataItemType_Float64 - -def XdmfDataItemType_UInt8(): - return _Xdmf.XdmfDataItemType_UInt8() -XdmfDataItemType_UInt8 = _Xdmf.XdmfDataItemType_UInt8 - -def XdmfDataItemType_UInt16(): - return _Xdmf.XdmfDataItemType_UInt16() -XdmfDataItemType_UInt16 = _Xdmf.XdmfDataItemType_UInt16 - -def XdmfDataItemType_UInt32(): - return _Xdmf.XdmfDataItemType_UInt32() -XdmfDataItemType_UInt32 = _Xdmf.XdmfDataItemType_UInt32 - class XdmfAttribute(XdmfDataItem): __swig_setmethods__ = {} for _s in [XdmfDataItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) @@ -463,7 +404,6 @@ class XdmfAttribute(XdmfDataItem): def getAttributeCenterAsString(self): return _Xdmf.XdmfAttribute_getAttributeCenterAsString(self) def write(self, *args): return _Xdmf.XdmfAttribute_write(self, *args) def printSelf(self): return _Xdmf.XdmfAttribute_printSelf(self) - def setNumberValues(self, *args): return _Xdmf.XdmfAttribute_setNumberValues(self, *args) XdmfAttribute_swigregister = _Xdmf.XdmfAttribute_swigregister XdmfAttribute_swigregister(XdmfAttribute) @@ -579,6 +519,33 @@ def XdmfAttributeType_GlobalId(): return _Xdmf.XdmfAttributeType_GlobalId() XdmfAttributeType_GlobalId = _Xdmf.XdmfAttributeType_GlobalId +class XdmfArray(XdmfItem): + __swig_setmethods__ = {} + for _s in [XdmfItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfArray, name, value) + __swig_getmethods__ = {} + for _s in [XdmfItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, XdmfArray, name) + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") + __repr__ = _swig_repr + __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfArray_New + if _newclass:New = staticmethod(_Xdmf.XdmfArray_New) + def getType(self): return _Xdmf.XdmfArray_getType(self) + def getHDF5Type(self): return _Xdmf.XdmfArray_getHDF5Type(self) + def getPrecision(self): return _Xdmf.XdmfArray_getPrecision(self) + def getSize(self): return _Xdmf.XdmfArray_getSize(self) + def getValues(self): return _Xdmf.XdmfArray_getValues(self) + def getValuesPointer(self): return _Xdmf.XdmfArray_getValuesPointer(self) + def printSelf(self): return _Xdmf.XdmfArray_printSelf(self) + def write(self, *args): return _Xdmf.XdmfArray_write(self, *args) + def setValues(self, *args): return _Xdmf.XdmfArray_setValues(self, *args) +XdmfArray_swigregister = _Xdmf.XdmfArray_swigregister +XdmfArray_swigregister(XdmfArray) + +def XdmfArray_New(): + return _Xdmf.XdmfArray_New() +XdmfArray_New = _Xdmf.XdmfArray_New + class XdmfDomain(XdmfItem): __swig_setmethods__ = {} for _s in [XdmfItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) @@ -617,7 +584,6 @@ class XdmfGeometry(XdmfDataItem): def setGeometryType(self, *args): return _Xdmf.XdmfGeometry_setGeometryType(self, *args) def getGeometryTypeAsString(self): return _Xdmf.XdmfGeometry_getGeometryTypeAsString(self) def getDimensions(self): return _Xdmf.XdmfGeometry_getDimensions(self) - def setNumberPoints(self, *args): return _Xdmf.XdmfGeometry_setNumberPoints(self, *args) def printSelf(self): return _Xdmf.XdmfGeometry_printSelf(self) def write(self, *args): return _Xdmf.XdmfGeometry_write(self, *args) XdmfGeometry_swigregister = _Xdmf.XdmfGeometry_swigregister @@ -743,7 +709,6 @@ class XdmfTopology(XdmfDataItem): def getTopologyType(self): return _Xdmf.XdmfTopology_getTopologyType(self) def setTopologyType(self, *args): return _Xdmf.XdmfTopology_setTopologyType(self, *args) def getNumberElements(self): return _Xdmf.XdmfTopology_getNumberElements(self) - def setNumberElements(self, *args): return _Xdmf.XdmfTopology_setNumberElements(self, *args) def getTopologyTypeAsString(self): return _Xdmf.XdmfTopology_getTopologyTypeAsString(self) def getNodesPerElement(self): return _Xdmf.XdmfTopology_getNodesPerElement(self) def printSelf(self): return _Xdmf.XdmfTopology_printSelf(self) @@ -924,5 +889,428 @@ def XdmfTopologyType_ThreeDCoRectMesh(): return _Xdmf.XdmfTopologyType_ThreeDCoRectMesh() XdmfTopologyType_ThreeDCoRectMesh = _Xdmf.XdmfTopologyType_ThreeDCoRectMesh +class CharVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, CharVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, CharVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.CharVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.CharVector___nonzero__(self) + def __bool__(self): return _Xdmf.CharVector___bool__(self) + def __len__(self): return _Xdmf.CharVector___len__(self) + def pop(self): return _Xdmf.CharVector_pop(self) + def __getslice__(self, *args): return _Xdmf.CharVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.CharVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.CharVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.CharVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.CharVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.CharVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.CharVector_append(self, *args) + def empty(self): return _Xdmf.CharVector_empty(self) + def size(self): return _Xdmf.CharVector_size(self) + def clear(self): return _Xdmf.CharVector_clear(self) + def swap(self, *args): return _Xdmf.CharVector_swap(self, *args) + def get_allocator(self): return _Xdmf.CharVector_get_allocator(self) + def begin(self): return _Xdmf.CharVector_begin(self) + def end(self): return _Xdmf.CharVector_end(self) + def rbegin(self): return _Xdmf.CharVector_rbegin(self) + def rend(self): return _Xdmf.CharVector_rend(self) + def pop_back(self): return _Xdmf.CharVector_pop_back(self) + def erase(self, *args): return _Xdmf.CharVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_CharVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.CharVector_push_back(self, *args) + def front(self): return _Xdmf.CharVector_front(self) + def back(self): return _Xdmf.CharVector_back(self) + def assign(self, *args): return _Xdmf.CharVector_assign(self, *args) + def resize(self, *args): return _Xdmf.CharVector_resize(self, *args) + def insert(self, *args): return _Xdmf.CharVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.CharVector_reserve(self, *args) + def capacity(self): return _Xdmf.CharVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_CharVector + __del__ = lambda self : None; +CharVector_swigregister = _Xdmf.CharVector_swigregister +CharVector_swigregister(CharVector) + +class ShortVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ShortVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ShortVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.ShortVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.ShortVector___nonzero__(self) + def __bool__(self): return _Xdmf.ShortVector___bool__(self) + def __len__(self): return _Xdmf.ShortVector___len__(self) + def pop(self): return _Xdmf.ShortVector_pop(self) + def __getslice__(self, *args): return _Xdmf.ShortVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.ShortVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.ShortVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.ShortVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.ShortVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.ShortVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.ShortVector_append(self, *args) + def empty(self): return _Xdmf.ShortVector_empty(self) + def size(self): return _Xdmf.ShortVector_size(self) + def clear(self): return _Xdmf.ShortVector_clear(self) + def swap(self, *args): return _Xdmf.ShortVector_swap(self, *args) + def get_allocator(self): return _Xdmf.ShortVector_get_allocator(self) + def begin(self): return _Xdmf.ShortVector_begin(self) + def end(self): return _Xdmf.ShortVector_end(self) + def rbegin(self): return _Xdmf.ShortVector_rbegin(self) + def rend(self): return _Xdmf.ShortVector_rend(self) + def pop_back(self): return _Xdmf.ShortVector_pop_back(self) + def erase(self, *args): return _Xdmf.ShortVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_ShortVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.ShortVector_push_back(self, *args) + def front(self): return _Xdmf.ShortVector_front(self) + def back(self): return _Xdmf.ShortVector_back(self) + def assign(self, *args): return _Xdmf.ShortVector_assign(self, *args) + def resize(self, *args): return _Xdmf.ShortVector_resize(self, *args) + def insert(self, *args): return _Xdmf.ShortVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.ShortVector_reserve(self, *args) + def capacity(self): return _Xdmf.ShortVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_ShortVector + __del__ = lambda self : None; +ShortVector_swigregister = _Xdmf.ShortVector_swigregister +ShortVector_swigregister(ShortVector) + +class IntVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.IntVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.IntVector___nonzero__(self) + def __bool__(self): return _Xdmf.IntVector___bool__(self) + def __len__(self): return _Xdmf.IntVector___len__(self) + def pop(self): return _Xdmf.IntVector_pop(self) + def __getslice__(self, *args): return _Xdmf.IntVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.IntVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.IntVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.IntVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.IntVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.IntVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.IntVector_append(self, *args) + def empty(self): return _Xdmf.IntVector_empty(self) + def size(self): return _Xdmf.IntVector_size(self) + def clear(self): return _Xdmf.IntVector_clear(self) + def swap(self, *args): return _Xdmf.IntVector_swap(self, *args) + def get_allocator(self): return _Xdmf.IntVector_get_allocator(self) + def begin(self): return _Xdmf.IntVector_begin(self) + def end(self): return _Xdmf.IntVector_end(self) + def rbegin(self): return _Xdmf.IntVector_rbegin(self) + def rend(self): return _Xdmf.IntVector_rend(self) + def pop_back(self): return _Xdmf.IntVector_pop_back(self) + def erase(self, *args): return _Xdmf.IntVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_IntVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.IntVector_push_back(self, *args) + def front(self): return _Xdmf.IntVector_front(self) + def back(self): return _Xdmf.IntVector_back(self) + def assign(self, *args): return _Xdmf.IntVector_assign(self, *args) + def resize(self, *args): return _Xdmf.IntVector_resize(self, *args) + def insert(self, *args): return _Xdmf.IntVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.IntVector_reserve(self, *args) + def capacity(self): return _Xdmf.IntVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_IntVector + __del__ = lambda self : None; +IntVector_swigregister = _Xdmf.IntVector_swigregister +IntVector_swigregister(IntVector) + +class LongVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, LongVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, LongVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.LongVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.LongVector___nonzero__(self) + def __bool__(self): return _Xdmf.LongVector___bool__(self) + def __len__(self): return _Xdmf.LongVector___len__(self) + def pop(self): return _Xdmf.LongVector_pop(self) + def __getslice__(self, *args): return _Xdmf.LongVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.LongVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.LongVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.LongVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.LongVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.LongVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.LongVector_append(self, *args) + def empty(self): return _Xdmf.LongVector_empty(self) + def size(self): return _Xdmf.LongVector_size(self) + def clear(self): return _Xdmf.LongVector_clear(self) + def swap(self, *args): return _Xdmf.LongVector_swap(self, *args) + def get_allocator(self): return _Xdmf.LongVector_get_allocator(self) + def begin(self): return _Xdmf.LongVector_begin(self) + def end(self): return _Xdmf.LongVector_end(self) + def rbegin(self): return _Xdmf.LongVector_rbegin(self) + def rend(self): return _Xdmf.LongVector_rend(self) + def pop_back(self): return _Xdmf.LongVector_pop_back(self) + def erase(self, *args): return _Xdmf.LongVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_LongVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.LongVector_push_back(self, *args) + def front(self): return _Xdmf.LongVector_front(self) + def back(self): return _Xdmf.LongVector_back(self) + def assign(self, *args): return _Xdmf.LongVector_assign(self, *args) + def resize(self, *args): return _Xdmf.LongVector_resize(self, *args) + def insert(self, *args): return _Xdmf.LongVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.LongVector_reserve(self, *args) + def capacity(self): return _Xdmf.LongVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_LongVector + __del__ = lambda self : None; +LongVector_swigregister = _Xdmf.LongVector_swigregister +LongVector_swigregister(LongVector) + +class FloatVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.FloatVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.FloatVector___nonzero__(self) + def __bool__(self): return _Xdmf.FloatVector___bool__(self) + def __len__(self): return _Xdmf.FloatVector___len__(self) + def pop(self): return _Xdmf.FloatVector_pop(self) + def __getslice__(self, *args): return _Xdmf.FloatVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.FloatVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.FloatVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.FloatVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.FloatVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.FloatVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.FloatVector_append(self, *args) + def empty(self): return _Xdmf.FloatVector_empty(self) + def size(self): return _Xdmf.FloatVector_size(self) + def clear(self): return _Xdmf.FloatVector_clear(self) + def swap(self, *args): return _Xdmf.FloatVector_swap(self, *args) + def get_allocator(self): return _Xdmf.FloatVector_get_allocator(self) + def begin(self): return _Xdmf.FloatVector_begin(self) + def end(self): return _Xdmf.FloatVector_end(self) + def rbegin(self): return _Xdmf.FloatVector_rbegin(self) + def rend(self): return _Xdmf.FloatVector_rend(self) + def pop_back(self): return _Xdmf.FloatVector_pop_back(self) + def erase(self, *args): return _Xdmf.FloatVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_FloatVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.FloatVector_push_back(self, *args) + def front(self): return _Xdmf.FloatVector_front(self) + def back(self): return _Xdmf.FloatVector_back(self) + def assign(self, *args): return _Xdmf.FloatVector_assign(self, *args) + def resize(self, *args): return _Xdmf.FloatVector_resize(self, *args) + def insert(self, *args): return _Xdmf.FloatVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.FloatVector_reserve(self, *args) + def capacity(self): return _Xdmf.FloatVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_FloatVector + __del__ = lambda self : None; +FloatVector_swigregister = _Xdmf.FloatVector_swigregister +FloatVector_swigregister(FloatVector) + +class DoubleVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.DoubleVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.DoubleVector___nonzero__(self) + def __bool__(self): return _Xdmf.DoubleVector___bool__(self) + def __len__(self): return _Xdmf.DoubleVector___len__(self) + def pop(self): return _Xdmf.DoubleVector_pop(self) + def __getslice__(self, *args): return _Xdmf.DoubleVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.DoubleVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.DoubleVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.DoubleVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.DoubleVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.DoubleVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.DoubleVector_append(self, *args) + def empty(self): return _Xdmf.DoubleVector_empty(self) + def size(self): return _Xdmf.DoubleVector_size(self) + def clear(self): return _Xdmf.DoubleVector_clear(self) + def swap(self, *args): return _Xdmf.DoubleVector_swap(self, *args) + def get_allocator(self): return _Xdmf.DoubleVector_get_allocator(self) + def begin(self): return _Xdmf.DoubleVector_begin(self) + def end(self): return _Xdmf.DoubleVector_end(self) + def rbegin(self): return _Xdmf.DoubleVector_rbegin(self) + def rend(self): return _Xdmf.DoubleVector_rend(self) + def pop_back(self): return _Xdmf.DoubleVector_pop_back(self) + def erase(self, *args): return _Xdmf.DoubleVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_DoubleVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.DoubleVector_push_back(self, *args) + def front(self): return _Xdmf.DoubleVector_front(self) + def back(self): return _Xdmf.DoubleVector_back(self) + def assign(self, *args): return _Xdmf.DoubleVector_assign(self, *args) + def resize(self, *args): return _Xdmf.DoubleVector_resize(self, *args) + def insert(self, *args): return _Xdmf.DoubleVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.DoubleVector_reserve(self, *args) + def capacity(self): return _Xdmf.DoubleVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_DoubleVector + __del__ = lambda self : None; +DoubleVector_swigregister = _Xdmf.DoubleVector_swigregister +DoubleVector_swigregister(DoubleVector) + +class UCharVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, UCharVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, UCharVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.UCharVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.UCharVector___nonzero__(self) + def __bool__(self): return _Xdmf.UCharVector___bool__(self) + def __len__(self): return _Xdmf.UCharVector___len__(self) + def pop(self): return _Xdmf.UCharVector_pop(self) + def __getslice__(self, *args): return _Xdmf.UCharVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.UCharVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.UCharVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.UCharVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.UCharVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.UCharVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.UCharVector_append(self, *args) + def empty(self): return _Xdmf.UCharVector_empty(self) + def size(self): return _Xdmf.UCharVector_size(self) + def clear(self): return _Xdmf.UCharVector_clear(self) + def swap(self, *args): return _Xdmf.UCharVector_swap(self, *args) + def get_allocator(self): return _Xdmf.UCharVector_get_allocator(self) + def begin(self): return _Xdmf.UCharVector_begin(self) + def end(self): return _Xdmf.UCharVector_end(self) + def rbegin(self): return _Xdmf.UCharVector_rbegin(self) + def rend(self): return _Xdmf.UCharVector_rend(self) + def pop_back(self): return _Xdmf.UCharVector_pop_back(self) + def erase(self, *args): return _Xdmf.UCharVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_UCharVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.UCharVector_push_back(self, *args) + def front(self): return _Xdmf.UCharVector_front(self) + def back(self): return _Xdmf.UCharVector_back(self) + def assign(self, *args): return _Xdmf.UCharVector_assign(self, *args) + def resize(self, *args): return _Xdmf.UCharVector_resize(self, *args) + def insert(self, *args): return _Xdmf.UCharVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.UCharVector_reserve(self, *args) + def capacity(self): return _Xdmf.UCharVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_UCharVector + __del__ = lambda self : None; +UCharVector_swigregister = _Xdmf.UCharVector_swigregister +UCharVector_swigregister(UCharVector) + +class UShortVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, UShortVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, UShortVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.UShortVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.UShortVector___nonzero__(self) + def __bool__(self): return _Xdmf.UShortVector___bool__(self) + def __len__(self): return _Xdmf.UShortVector___len__(self) + def pop(self): return _Xdmf.UShortVector_pop(self) + def __getslice__(self, *args): return _Xdmf.UShortVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.UShortVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.UShortVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.UShortVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.UShortVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.UShortVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.UShortVector_append(self, *args) + def empty(self): return _Xdmf.UShortVector_empty(self) + def size(self): return _Xdmf.UShortVector_size(self) + def clear(self): return _Xdmf.UShortVector_clear(self) + def swap(self, *args): return _Xdmf.UShortVector_swap(self, *args) + def get_allocator(self): return _Xdmf.UShortVector_get_allocator(self) + def begin(self): return _Xdmf.UShortVector_begin(self) + def end(self): return _Xdmf.UShortVector_end(self) + def rbegin(self): return _Xdmf.UShortVector_rbegin(self) + def rend(self): return _Xdmf.UShortVector_rend(self) + def pop_back(self): return _Xdmf.UShortVector_pop_back(self) + def erase(self, *args): return _Xdmf.UShortVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_UShortVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.UShortVector_push_back(self, *args) + def front(self): return _Xdmf.UShortVector_front(self) + def back(self): return _Xdmf.UShortVector_back(self) + def assign(self, *args): return _Xdmf.UShortVector_assign(self, *args) + def resize(self, *args): return _Xdmf.UShortVector_resize(self, *args) + def insert(self, *args): return _Xdmf.UShortVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.UShortVector_reserve(self, *args) + def capacity(self): return _Xdmf.UShortVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_UShortVector + __del__ = lambda self : None; +UShortVector_swigregister = _Xdmf.UShortVector_swigregister +UShortVector_swigregister(UShortVector) + +class UIntVector(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, UIntVector, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, UIntVector, name) + __repr__ = _swig_repr + def iterator(self): return _Xdmf.UIntVector_iterator(self) + def __iter__(self): return self.iterator() + def __nonzero__(self): return _Xdmf.UIntVector___nonzero__(self) + def __bool__(self): return _Xdmf.UIntVector___bool__(self) + def __len__(self): return _Xdmf.UIntVector___len__(self) + def pop(self): return _Xdmf.UIntVector_pop(self) + def __getslice__(self, *args): return _Xdmf.UIntVector___getslice__(self, *args) + def __setslice__(self, *args): return _Xdmf.UIntVector___setslice__(self, *args) + def __delslice__(self, *args): return _Xdmf.UIntVector___delslice__(self, *args) + def __delitem__(self, *args): return _Xdmf.UIntVector___delitem__(self, *args) + def __getitem__(self, *args): return _Xdmf.UIntVector___getitem__(self, *args) + def __setitem__(self, *args): return _Xdmf.UIntVector___setitem__(self, *args) + def append(self, *args): return _Xdmf.UIntVector_append(self, *args) + def empty(self): return _Xdmf.UIntVector_empty(self) + def size(self): return _Xdmf.UIntVector_size(self) + def clear(self): return _Xdmf.UIntVector_clear(self) + def swap(self, *args): return _Xdmf.UIntVector_swap(self, *args) + def get_allocator(self): return _Xdmf.UIntVector_get_allocator(self) + def begin(self): return _Xdmf.UIntVector_begin(self) + def end(self): return _Xdmf.UIntVector_end(self) + def rbegin(self): return _Xdmf.UIntVector_rbegin(self) + def rend(self): return _Xdmf.UIntVector_rend(self) + def pop_back(self): return _Xdmf.UIntVector_pop_back(self) + def erase(self, *args): return _Xdmf.UIntVector_erase(self, *args) + def __init__(self, *args): + this = _Xdmf.new_UIntVector(*args) + try: self.this.append(this) + except: self.this = this + def push_back(self, *args): return _Xdmf.UIntVector_push_back(self, *args) + def front(self): return _Xdmf.UIntVector_front(self) + def back(self): return _Xdmf.UIntVector_back(self) + def assign(self, *args): return _Xdmf.UIntVector_assign(self, *args) + def resize(self, *args): return _Xdmf.UIntVector_resize(self, *args) + def insert(self, *args): return _Xdmf.UIntVector_insert(self, *args) + def reserve(self, *args): return _Xdmf.UIntVector_reserve(self, *args) + def capacity(self): return _Xdmf.UIntVector_capacity(self) + __swig_destroy__ = _Xdmf.delete_UIntVector + __del__ = lambda self : None; +UIntVector_swigregister = _Xdmf.UIntVector_swigregister +UIntVector_swigregister(UIntVector) + diff --git a/XdmfArray.cpp b/XdmfArray.cpp new file mode 100644 index 00000000..080d41eb --- /dev/null +++ b/XdmfArray.cpp @@ -0,0 +1,288 @@ +/* + * XdmfArray.cpp + * + * Created on: Jan 29, 2010 + * Author: kleiter + */ + +#include "XdmfArray.hpp" +#include "XdmfVisitor.hpp" +#include + +class XdmfArrayGetPrecision : public boost::static_visitor { +public: + XdmfArrayGetPrecision() + { + } + + int operator()(const std::vector & array) const + { + return 1; + } + + int operator()(const std::vector & array) const + { + return 2; + } + + int operator()(const std::vector & array) const + { + return 4; + } + + int operator()(const std::vector & array) const + { + return 8; + } + + int operator()(const std::vector & array) const + { + return 4; + } + + int operator()(const std::vector & array) const + { + return 8; + } + + int operator()(const std::vector & array) const + { + return 1; + } + + int operator()(const std::vector & array) const + { + return 2; + } + + int operator()(const std::vector & array) const + { + return 4; + } +}; + +class XdmfArrayGetType : public boost::static_visitor { +public: + XdmfArrayGetType() + { + } + + std::string operator()(const std::vector & array) const + { + return "Char"; + } + + std::string operator()(const std::vector & array) const + { + return "Short"; + } + + std::string operator()(const std::vector & array) const + { + return "Int"; + } + + std::string operator()(const std::vector & array) const + { + return "Int"; + } + + std::string operator()(const std::vector & array) const + { + return "Float"; + } + + std::string operator()(const std::vector & array) const + { + return "Float"; + } + + std::string operator()(const std::vector & array) const + { + return "UChar"; + } + + std::string operator()(const std::vector & array) const + { + return "UShort"; + } + + std::string operator()(const std::vector & array) const + { + return "UInt"; + } +}; + +class XdmfArrayGetHDF5Type : public boost::static_visitor { +public: + XdmfArrayGetHDF5Type() + { + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_CHAR; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_SHORT; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_INT; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_LONG; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_FLOAT; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_DOUBLE; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_UCHAR; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_USHORT; + } + + hid_t operator()(const std::vector & array) const + { + return H5T_NATIVE_UINT; + } +}; + +class XdmfArrayGetSize : public boost::static_visitor { +public: + + XdmfArrayGetSize() + { + } + + template int operator()(const std::vector & array) const + { + return array.size(); + } +}; + +class XdmfArrayGetValues : public boost::static_visitor { +public: + + XdmfArrayGetValues() + { + } + + std::string operator()(const std::vector & array) const + { + std::stringstream toReturn; + for(int i=0; i std::string operator()(const std::vector & array) const + { + std::stringstream toReturn; + for(int i=0; i { +public: + XdmfArrayGetValuesPointer() + { + } + + template void* operator()(std::vector & array) const + { + return &array[0]; + } +}; + +class XdmfArrayGetValuesPointerConst : public boost::static_visitor { +public: + + XdmfArrayGetValuesPointerConst() + { + } + + template const void* const operator()(const std::vector & array) const + { + return &array[0]; + } +}; + +XdmfArray::XdmfArray() : + mInitialized(false) +{ + std::cout << "Created Array " << this << std::endl; +} + +XdmfArray::~XdmfArray() +{ + std::cout << "Deleted Array " << this << std::endl; +} + +hid_t XdmfArray::getHDF5Type() const +{ + return boost::apply_visitor( XdmfArrayGetHDF5Type(), mArray); +} + +int XdmfArray::getPrecision() const +{ + return boost::apply_visitor( XdmfArrayGetPrecision(), mArray); +} + +int XdmfArray::getSize() const +{ + return boost::apply_visitor( XdmfArrayGetSize(), mArray); +} + +std::string XdmfArray::getType() const +{ + return boost::apply_visitor( XdmfArrayGetType(), mArray); +} + +std::string XdmfArray::getValues() const +{ + return boost::apply_visitor( XdmfArrayGetValues(), mArray); +} + +void* XdmfArray::getValuesPointer() +{ + return boost::apply_visitor( XdmfArrayGetValuesPointer(), mArray); +} + +const void* const XdmfArray::getValuesPointer() const +{ + return boost::apply_visitor( XdmfArrayGetValuesPointerConst(), mArray); +} + +std::string XdmfArray::printSelf() const +{ + return ""; +} + +void XdmfArray::write(boost::shared_ptr visitor) const +{ + visitor->visit(this); +} diff --git a/XdmfArray.hpp b/XdmfArray.hpp new file mode 100644 index 00000000..77e73d6e --- /dev/null +++ b/XdmfArray.hpp @@ -0,0 +1,165 @@ +/* + * XdmfArray.hpp + * + * Created on: Jan 25, 2010 + * Author: kleiter + */ + +#ifndef XDMFARRAY_HPP_ +#define XDMFARRAY_HPP_ + +// Includes +#include "XdmfItem.hpp" +#include +#include +#include + +template +class XdmfArraySetValues : public boost::static_visitor { +public: + + XdmfArraySetValues(int startIndex, T* valuesPointer, int numValues, int arrayStride = 1, int valuesStride = 1) : + mStartIndex(startIndex), + mValuesPointer(valuesPointer), + mNumValues(numValues), + mArrayStride(arrayStride), + mValuesStride(valuesStride) + { + } + + template void operator()(std::vector & array) const + { + int size = mStartIndex + mNumValues; + if(mArrayStride > 1) + { + size = mStartIndex + mNumValues * mArrayStride - 1; + } + if(array.size() < size) + { + array.resize(size); + } + for(int i=0; i void setValues(int startIndex, T* valuesPointer, int numValues = 1, int arrayStride = 1, int valuesStride = 1) + { + if(!mInitialized) + { + // Set type of variant to type of pointer + mArray = std::vector(); + mInitialized = true; + } + boost::apply_visitor( XdmfArraySetValues(startIndex, valuesPointer, numValues, arrayStride, valuesStride), mArray); + } + + /** + * Copy the values from a vector into this array + * + * @param array the vector to copy into this array. + */ + template void setValues(std::vector & array) + { + mArray = array; + } + + virtual void write(boost::shared_ptr) const; + +protected: + + XdmfArray(); + virtual ~XdmfArray(); + +private: + + bool mInitialized; + + boost::variant, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector, + std::vector > mArray; +}; + +#endif /* XDMFARRAY_HPP_ */ diff --git a/XdmfAttribute.cpp b/XdmfAttribute.cpp index bce81d04..c12db659 100644 --- a/XdmfAttribute.cpp +++ b/XdmfAttribute.cpp @@ -61,11 +61,6 @@ void XdmfAttribute::setName(const std::string& name) mName= name; } -void XdmfAttribute::setNumberValues(int numValues) -{ - mNumberValues = numValues; -} - void XdmfAttribute::write(boost::shared_ptr visitor) const { visitor->visit(this); diff --git a/XdmfAttribute.hpp b/XdmfAttribute.hpp index 7c3fe392..2f13a708 100644 --- a/XdmfAttribute.hpp +++ b/XdmfAttribute.hpp @@ -8,6 +8,7 @@ #ifndef XDMFATTRIBUTE_HPP_ #define XDMFATTRIBUTE_HPP_ +// Includes #include "XdmfAttributeCenter.hpp" #include "XdmfAttributeType.hpp" #include "XdmfDataItem.hpp" @@ -74,13 +75,6 @@ public: */ std::string getAttributeCenterAsString() const; - /** - * Set the number of values this attribute contains. - * - * @param an int giving the number of values. - */ - void setNumberValues(int numValues); - void write(boost::shared_ptr visitor) const; virtual std::string printSelf() const; diff --git a/XdmfDataItem.cpp b/XdmfDataItem.cpp index 8fe5d15a..e52d8cc1 100644 --- a/XdmfDataItem.cpp +++ b/XdmfDataItem.cpp @@ -5,12 +5,11 @@ * Author: kleiter */ +#include "XdmfArray.hpp" #include "XdmfDataItem.hpp" -#include "XdmfVisitor.hpp" XdmfDataItem::XdmfDataItem() : - mDataItemType(XdmfDataItemType::Unknown()), - mNumberValues(0) + mArray(XdmfArray::New()) { std::cout << "Created DataItem " << this << std::endl; } @@ -25,126 +24,17 @@ std::string XdmfDataItem::printSelf() const return "XdmfDataItem"; } -template <> -void XdmfDataItem::setValues(char* dataPointer) +void XdmfDataItem::setArray(boost::shared_ptr array) { - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Int8(); + mArray = array; } -template <> -void XdmfDataItem::setValues(unsigned char* dataPointer) +boost::shared_ptr XdmfDataItem::getArray() { - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::UInt8(); + return mArray; } -template <> -void XdmfDataItem::setValues(short* dataPointer) +boost::shared_ptr XdmfDataItem::getArray() const { - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Int16(); + return mArray; } - -template <> -void XdmfDataItem::setValues(unsigned short* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::UInt16(); -} - -template <> -void XdmfDataItem::setValues(int* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Int32(); -} - -template <> -void XdmfDataItem::setValues(unsigned int* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::UInt32(); -} - -template <> -void XdmfDataItem::setValues(long* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Int64(); -} - -template <> -void XdmfDataItem::setValues(float* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Float32(); -} - -template <> -void XdmfDataItem::setValues(double* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Float64(); -} - -template -void XdmfDataItem::setValues(T* dataPointer) -{ - mDataPointer = dataPointer; - mDataItemType = XdmfDataItemType::Unknown(); -} - -void* XdmfDataItem::getValues() -{ - return mDataPointer; -} - -const void* const XdmfDataItem::getValues() const -{ - return mDataPointer; -} - -int XdmfDataItem::getNumberValues() const -{ - return mNumberValues; -} - -hid_t XdmfDataItem::getHDF5DataType() const -{ - return mDataItemType.getHDF5DataType(); -} - -std::string XdmfDataItem::getName() const -{ - return mDataItemType.getName(); -} - -int XdmfDataItem::getPrecision() const -{ - return mDataItemType.getPrecision(); -} - -//std::string getValuesAsString() const -//{ - -//} - -/* -template -T* XdmfDataItem::getValues() -{ - return (T*)mDataPointer; -} - -template -const T* const XdmfDataItem::getValues() const -{ - return (T*)mDataPointer; -} -*/ - -//void XdmfDataItem::write(boost::shared_ptr visitor) const -//{ -// visitor->visit(this); -//} diff --git a/XdmfDataItem.hpp b/XdmfDataItem.hpp index c16c2d4c..a2717aca 100644 --- a/XdmfDataItem.hpp +++ b/XdmfDataItem.hpp @@ -9,30 +9,36 @@ #ifndef XDMFDATAITEM_HPP_ #define XDMFDATAITEM_HPP_ -#include "XdmfDataItemType.hpp" +// Forward Declarations +class XdmfArray; + +// Includes #include "XdmfItem.hpp" class XdmfDataItem : public XdmfItem { public: - //XdmfNewMacro(XdmfDataItem); - - template void setValues(T * dataPointer); - - //template T* getValues(); - void* getValues(); - - //template const T* const getValues() const; - const void* const getValues() const; - - hid_t getHDF5DataType() const; - - std::string getName() const; - - int getPrecision() const; - - int getNumberValues() const; + /** + * Attach an array to this dataitem. + * + * @param a smart pointer to the array. + */ + void setArray(boost::shared_ptr array); + + /** + * Get the array attached to this dataitem. + * + * @return a smart pointer to the array. + */ + boost::shared_ptr getArray(); + + /** + * Get the array attached to this dataitem (const version). + * + * @return a smart pointer to the array. + */ + boost::shared_ptr getArray() const; std::string printSelf() const; @@ -40,8 +46,6 @@ public: protected: - int mNumberValues; - XdmfDataItem(); virtual ~XdmfDataItem(); @@ -50,8 +54,7 @@ private: XdmfDataItem(const XdmfDataItem&); // Not implemented. void operator=(const XdmfDataItem&); // Not implemented. - void* mDataPointer; - XdmfDataItemType mDataItemType; + boost::shared_ptr mArray; }; #endif /* XDMFDATAITEM_HPP_ */ diff --git a/XdmfDataItemType.cpp b/XdmfDataItemType.cpp deleted file mode 100644 index eaecf34e..00000000 --- a/XdmfDataItemType.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/* - * XdmfDataItemType.cpp - * - * Created on: Jan 29, 2010 - * Author: kleiter - */ - -#include "XdmfDataItemType.hpp" - -// Supported XdmfDataItemTypes -XdmfDataItemType XdmfDataItemType::Unknown() -{ - return XdmfDataItemType("Unknown", 0, 0); -} - -XdmfDataItemType XdmfDataItemType::Int8() -{ - return XdmfDataItemType("Char", H5T_NATIVE_CHAR, 1); -} - -XdmfDataItemType XdmfDataItemType::Int16() -{ - return XdmfDataItemType("Short", H5T_NATIVE_SHORT, 2); -} - -XdmfDataItemType XdmfDataItemType::Int32() -{ - return XdmfDataItemType("Int", H5T_NATIVE_INT, 4); -} - -XdmfDataItemType XdmfDataItemType::Int64() -{ - return XdmfDataItemType("Int", H5T_NATIVE_LONG, 8); -} - -XdmfDataItemType XdmfDataItemType::Float32() -{ - return XdmfDataItemType("Float", H5T_NATIVE_FLOAT, 4); -} - -XdmfDataItemType XdmfDataItemType::Float64() -{ - return XdmfDataItemType("Float", H5T_NATIVE_DOUBLE, 8); -} - -XdmfDataItemType XdmfDataItemType::UInt8() -{ - return XdmfDataItemType("UChar", H5T_NATIVE_UCHAR, 1); -} - -XdmfDataItemType XdmfDataItemType::UInt16() -{ - return XdmfDataItemType("UShort", H5T_NATIVE_USHORT, 2); -} - -XdmfDataItemType XdmfDataItemType::UInt32() -{ - return XdmfDataItemType("UInt", H5T_NATIVE_UINT, 4); -} - -XdmfDataItemType::XdmfDataItemType(const std::string& name, hid_t hdfDataType, int precision) : - mName(name), - mHDF5DataType(hdfDataType), - mPrecision(precision) -{}; - -XdmfDataItemType::XdmfDataItemType(const XdmfDataItemType& dataItemType): - mName(dataItemType.mName), - mHDF5DataType(dataItemType.mHDF5DataType), - mPrecision(dataItemType.mPrecision) -{ -} - -XdmfDataItemType& XdmfDataItemType::operator=(const XdmfDataItemType& dataItemType) -{ - if(this != &dataItemType) - { - mName = dataItemType.mName; - mHDF5DataType = dataItemType.mHDF5DataType; - mPrecision = dataItemType.mPrecision; - } - return *this; -} - -bool XdmfDataItemType::operator==(const XdmfDataItemType& dataItemType) const -{ - return mName.compare(dataItemType.mName) == 0 && mHDF5DataType == dataItemType.mHDF5DataType && mPrecision == dataItemType.mPrecision; -} - -bool XdmfDataItemType::operator!=(const XdmfDataItemType& dataItemType) const -{ - return !this->operator==(dataItemType); -} - -std::string XdmfDataItemType::getName() const -{ - return mName; -} - -hid_t XdmfDataItemType::getHDF5DataType() const -{ - return mHDF5DataType; -} - -int XdmfDataItemType::getPrecision() const -{ - return mPrecision; -} diff --git a/XdmfDataItemType.hpp b/XdmfDataItemType.hpp deleted file mode 100644 index 15c8c98c..00000000 --- a/XdmfDataItemType.hpp +++ /dev/null @@ -1,86 +0,0 @@ -/* - * XdmfDataItemType.hpp - * - * Created on: Jan 25, 2010 - * Author: kleiter - */ - -#ifndef XDMFDATAITEMTYPE_HPP_ -#define XDMFDATAITEMTYPE_HPP_ - -#include -#include - -class XdmfDataItemType { - -public: - - // Supported Xdmf Data Item Types - static XdmfDataItemType Unknown(); - static XdmfDataItemType Int8(); - static XdmfDataItemType Int16(); - static XdmfDataItemType Int32(); - static XdmfDataItemType Int64(); - static XdmfDataItemType Float32(); - static XdmfDataItemType Float64(); - static XdmfDataItemType UInt8(); - static XdmfDataItemType UInt16(); - static XdmfDataItemType UInt32(); - - /** - * Get the name of this data item type. - * - * @return a string containing the name. - */ - std::string getName() const; - - /** - * Return the equivalent HDF5 data type for this data item type. - * - * @return a hid_t giving the equivalent HDF5 data type. - */ - hid_t getHDF5DataType() const; - - /** - * Return the precision(number of bytes) of this data item type. - * - * @return an int containing the precision. - */ - int getPrecision() const; - - /* - * Compare two XdmfDataItemTypes for equality. - * - * @param an XdmfDataItemType to compare equality to. - * @return true iff the XdmfDataItemTypes are equal. - */ - bool operator==(const XdmfDataItemType& attributeType) const; - - /** - * Compare two XdmfDataItemTypes for inequality. - * - * @param XdmfDataItemType to compare inequality to. - * @return true iff the XdmfDataItemTypes are not equal. - */ - bool operator!=(const XdmfDataItemType& top) const; - - XdmfDataItemType(const XdmfDataItemType& dataItemType); - XdmfDataItemType& operator=(const XdmfDataItemType& dataItemType); - -protected: - - /** - * Protected constructor for XdmfDataItemType. The constructor is protected because all data item types supported - * by Xdmf should be accessed through more specific static methods that construct XdmfDataItemTypes - i.e. XdmfDataItemType::Int8(). - */ - XdmfDataItemType(const std::string& name, hid_t HDFDataType, int precision); - -private: - - static XdmfDataItemType* UnknownPtr; - std::string mName; - hid_t mHDF5DataType; - int mPrecision; -}; - -#endif /* XDMFDATAITEMTYPE_HPP_ */ diff --git a/XdmfGeometry.cpp b/XdmfGeometry.cpp index 0568ae25..815e08f3 100644 --- a/XdmfGeometry.cpp +++ b/XdmfGeometry.cpp @@ -28,7 +28,6 @@ XdmfGeometryType XdmfGeometry::getGeometryType() const void XdmfGeometry::setGeometryType(const XdmfGeometryType& geomType) { mGeometryType = geomType; - mNumberValues = mNumberPoints * mGeometryType.getDimensions(); } std::string XdmfGeometry::getGeometryTypeAsString() const @@ -41,12 +40,6 @@ int XdmfGeometry::getDimensions() const return mGeometryType.getDimensions(); } -void XdmfGeometry::setNumberPoints(int numberPoints) -{ - mNumberPoints = numberPoints; - mNumberValues = mNumberPoints * mGeometryType.getDimensions(); -} - std::string XdmfGeometry::printSelf() const { return "XdmfGeometry"; diff --git a/XdmfGeometry.hpp b/XdmfGeometry.hpp index cf943743..1a555167 100644 --- a/XdmfGeometry.hpp +++ b/XdmfGeometry.hpp @@ -46,8 +46,6 @@ public: */ int getDimensions() const; - void setNumberPoints(int numberPoints); - virtual std::string printSelf() const; virtual void write(boost::shared_ptr visitor) const; diff --git a/XdmfGrid.cpp b/XdmfGrid.cpp index 2184d1ea..34e59e70 100644 --- a/XdmfGrid.cpp +++ b/XdmfGrid.cpp @@ -12,9 +12,9 @@ #include XdmfGrid::XdmfGrid() : -mGeometry(XdmfGeometry::New()), -mTopology(XdmfTopology::New()), -mName("Grid") + mGeometry(XdmfGeometry::New()), + mTopology(XdmfTopology::New()), + mName("Grid") { std::cout << "Created Grid " << this << std::endl; } diff --git a/XdmfGrid.hpp b/XdmfGrid.hpp index 3e5b4e1b..3b035d2b 100644 --- a/XdmfGrid.hpp +++ b/XdmfGrid.hpp @@ -1,5 +1,4 @@ // Kenneth Leiter -// Xdmf Smart Pointer Test #ifndef XDMFGRID_HPP_ #define XDMFGRID_HPP_ diff --git a/XdmfPython.cpp b/XdmfPython.cpp index 296e4c33..af3439a6 100644 --- a/XdmfPython.cpp +++ b/XdmfPython.cpp @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 1.3.40 + * Version 1.3.37 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make @@ -749,7 +749,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { -/* Compatibility macros for Python 3 */ +/* Compatibility marcos for Python 3 */ #if PY_VERSION_HEX >= 0x03000000 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) @@ -772,35 +772,17 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { # 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) { #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; + return PyBytes_AsString(str); #else return PyString_AsString(str); #endif } -#if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) -#else -# define SWIG_Python_str_DelForPy3(x) -#endif - - SWIGINTERN PyObject* SWIG_Python_str_FromChar(const char *c) { @@ -955,13 +937,11 @@ SWIG_Python_AddErrorMsg(const char* mesg) 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); + PyErr_Format(type, "%s %s", SWIG_Python_str_AsChar(old_str), mesg); Py_DECREF(old_str); Py_DECREF(value); } else { @@ -1472,7 +1452,9 @@ SwigPyObject_repr(SwigPyObject *v, PyObject *args) #endif { const char *name = SWIG_TypePrettyName(v->ty); - PyObject *repr = SWIG_Python_str_FromFormat("", name, v); + PyObject *hex = SwigPyObject_hex(v); + PyObject *repr = SWIG_Python_str_FromFormat("", name, hex); + Py_DECREF(hex); if (v->next) { #ifdef METH_NOARGS PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); @@ -1494,16 +1476,13 @@ SwigPyObject_repr(SwigPyObject *v, PyObject *args) SWIGRUNTIME int SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { - char *str; #ifdef METH_NOARGS PyObject *repr = SwigPyObject_repr(v); #else PyObject *repr = SwigPyObject_repr(v, NULL); #endif if (repr) { - str = SWIG_Python_str_AsChar(repr); - fputs(str, fp); - SWIG_Python_str_DelForPy3(str); + fputs(SWIG_Python_str_AsChar(repr), fp); Py_DECREF(repr); return 0; } else { @@ -1527,7 +1506,7 @@ SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) return (i < j) ? -1 : ((i > j) ? 1 : 0); } -/* Added for Python 3.x, would it also be useful for Python 2.x? */ +/* Added for Python 3.x, whould it also useful for Python 2.x? */ SWIGRUNTIME PyObject* SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) { @@ -1575,7 +1554,7 @@ SwigPyObject_dealloc(PyObject *v) /* destroy is always a VARARGS method */ PyObject *res; if (data->delargs) { - /* we need to create a temporary object to carry the destroy operation */ + /* we need to create a temporal object to carry the destroy operation */ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); res = SWIG_Python_CallFunctor(destroy, tmp); Py_DECREF(tmp); @@ -1750,11 +1729,7 @@ _PySwigObject_type(void) { 0, /*nb_coerce*/ #endif (unaryfunc)SwigPyObject_long, /*nb_int*/ -#if PY_VERSION_HEX < 0x03000000 (unaryfunc)SwigPyObject_long, /*nb_long*/ -#else - 0, /*nb_reserved*/ -#endif (unaryfunc)0, /*nb_float*/ #if PY_VERSION_HEX < 0x03000000 (unaryfunc)SwigPyObject_oct, /*nb_oct*/ @@ -1776,7 +1751,7 @@ _PySwigObject_type(void) { if (!type_init) { const PyTypeObject tmp = { - /* PyObject header changed in Python 3 */ + /* PyOjbect header changed in Python 3 */ #if PY_VERSION_HEX >= 0x03000000 PyVarObject_HEAD_INIT(&PyType_Type, 0) #else @@ -1794,11 +1769,7 @@ _PySwigObject_type(void) { (getattrfunc)0, /* tp_getattr */ #endif (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 */ -#else - (cmpfunc)SwigPyObject_compare, /* tp_compare */ -#endif + (cmpfunc)SwigPyObject_compare, /* tp_compare */ (reprfunc)SwigPyObject_repr, /* tp_repr */ &SwigPyObject_as_number, /* tp_as_number */ 0, /* tp_as_sequence */ @@ -1845,7 +1816,7 @@ _PySwigObject_type(void) { #endif }; swigpyobject_type = tmp; - /* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */ + /* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */ #if PY_VERSION_HEX < 0x03000000 swigpyobject_type.ob_type = &PyType_Type; #endif @@ -1969,18 +1940,14 @@ _PySwigPacked_type(void) { (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 */ + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ + (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 */ + 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 */ @@ -2252,10 +2219,10 @@ SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { /* 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) + if (desc) { desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; - if (!desc) - return SWIG_ERROR; + if (!desc) return SWIG_ERROR; + } if (ty) { swig_cast_info *tc = SWIG_TypeCheck(desc,ty); if (tc) { @@ -2293,7 +2260,7 @@ SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *t * ----------------------------------------------------------------------------- */ /* - Create a new instance object, without calling __init__, and set the + Create a new instance object, whitout calling __init__, and set the 'this' attribute. */ @@ -2324,6 +2291,7 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) } else { #if PY_VERSION_HEX >= 0x03000000 inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); + Py_INCREF(data->newargs); PyObject_SetAttr(inst, SWIG_This(), swig_this); Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; #else @@ -2564,23 +2532,21 @@ SWIG_Python_TypeQuery(const char *type) 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)); + PyErr_Format(type, "%s %s", mesg, SWIG_Python_str_AsChar(old_str)); } else { - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + PyErr_Format(type, "%s %s", SWIG_Python_str_AsChar(old_str), mesg); } - SWIG_Python_str_DelForPy3(tmp); Py_DECREF(old_str); } return 1; @@ -2632,7 +2598,6 @@ SWIG_Python_TypeError(const char *type, PyObject *obj) 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); @@ -2654,12 +2619,10 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) void *result; if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { PyErr_Clear(); -#if SWIG_POINTER_EXCEPTION - if (flags) { + if (flags & SWIG_POINTER_EXCEPTION) { SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); SWIG_Python_ArgFail(argnum); } -#endif } return result; } @@ -2685,11 +2648,11 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) /* -------- TYPES TABLE (BEGIN) -------- */ -#define SWIGTYPE_p_XdmfAttribute swig_types[0] -#define SWIGTYPE_p_XdmfAttributeCenter swig_types[1] -#define SWIGTYPE_p_XdmfAttributeType swig_types[2] -#define SWIGTYPE_p_XdmfDataItem swig_types[3] -#define SWIGTYPE_p_XdmfDataItemType swig_types[4] +#define SWIGTYPE_p_XdmfArray swig_types[0] +#define SWIGTYPE_p_XdmfAttribute swig_types[1] +#define SWIGTYPE_p_XdmfAttributeCenter swig_types[2] +#define SWIGTYPE_p_XdmfAttributeType swig_types[3] +#define SWIGTYPE_p_XdmfDataItem swig_types[4] #define SWIGTYPE_p_XdmfDomain swig_types[5] #define SWIGTYPE_p_XdmfGeometry swig_types[6] #define SWIGTYPE_p_XdmfGeometryType swig_types[7] @@ -2699,24 +2662,59 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) #define SWIGTYPE_p_XdmfTopology swig_types[11] #define SWIGTYPE_p_XdmfTopologyType swig_types[12] #define SWIGTYPE_p_XdmfVisitor swig_types[13] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_const_t swig_types[14] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t swig_types[15] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t swig_types[16] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t swig_types[17] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_const_t swig_types[18] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t swig_types[19] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_const_t swig_types[20] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t swig_types[21] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t swig_types[22] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t swig_types[23] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_const_t swig_types[24] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t swig_types[25] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t swig_types[26] -#define SWIGTYPE_p_char swig_types[27] -#define SWIGTYPE_p_std__invalid_argument swig_types[28] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[29] -static swig_type_info *swig_types[31]; -static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0}; +#define SWIGTYPE_p_allocator_type swig_types[14] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t swig_types[15] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t swig_types[16] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_const_t swig_types[17] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t swig_types[18] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t swig_types[19] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t swig_types[20] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_const_t swig_types[21] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t swig_types[22] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_const_t swig_types[23] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t swig_types[24] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t swig_types[25] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t swig_types[26] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_const_t swig_types[27] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t swig_types[28] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t swig_types[29] +#define SWIGTYPE_p_char swig_types[30] +#define SWIGTYPE_p_difference_type swig_types[31] +#define SWIGTYPE_p_double swig_types[32] +#define SWIGTYPE_p_float swig_types[33] +#define SWIGTYPE_p_hid_t swig_types[34] +#define SWIGTYPE_p_int swig_types[35] +#define SWIGTYPE_p_long swig_types[36] +#define SWIGTYPE_p_p_PyObject swig_types[37] +#define SWIGTYPE_p_short swig_types[38] +#define SWIGTYPE_p_size_type swig_types[39] +#define SWIGTYPE_p_std__invalid_argument swig_types[40] +#define SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t swig_types[41] +#define SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t__allocator_type swig_types[42] +#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[43] +#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t__allocator_type swig_types[44] +#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t swig_types[45] +#define SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t__allocator_type swig_types[46] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[47] +#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[48] +#define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[49] +#define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t__allocator_type swig_types[50] +#define SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t swig_types[51] +#define SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t__allocator_type swig_types[52] +#define SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t swig_types[53] +#define SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t__allocator_type swig_types[54] +#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[55] +#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t__allocator_type swig_types[56] +#define SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t swig_types[57] +#define SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t__allocator_type swig_types[58] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[59] +#define SWIGTYPE_p_unsigned_char swig_types[60] +#define SWIGTYPE_p_unsigned_int swig_types[61] +#define SWIGTYPE_p_unsigned_short swig_types[62] +#define SWIGTYPE_p_value_type swig_types[63] +#define SWIGTYPE_p_void swig_types[64] +static swig_type_info *swig_types[66]; +static swig_module_info swig_module = {swig_types, 65, 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) @@ -2740,7 +2738,7 @@ static swig_module_info swig_module = {swig_types, 30, 0, 0, 0, 0}; #endif #define SWIG_name "_Xdmf" -#define SWIGVERSION 0x010340 +#define SWIGVERSION 0x010337 #define SWIG_VERSION SWIGVERSION @@ -3210,27 +3208,19 @@ SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) { #if PY_VERSION_HEX>=0x03000000 - if (PyUnicode_Check(obj)) + if (PyUnicode_Check(obj)) #else - if (PyString_Check(obj)) + if (PyString_Check(obj)) #endif { char *cstr; Py_ssize_t len; #if PY_VERSION_HEX>=0x03000000 - 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); PyBytes_AsStringAndSize(obj, &cstr, &len); - if(alloc) *alloc = SWIG_NEWOBJ; #else PyString_AsStringAndSize(obj, &cstr, &len); #endif - if (cptr) { + if (cptr) { if (alloc) { /* In python the user should not be able to modify the inner @@ -3255,16 +3245,10 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) *alloc = SWIG_OLDOBJ; } } else { - #if PY_VERSION_HEX>=0x03000000 - assert(0); /* Should never reach here in Python 3 */ - #endif *cptr = SWIG_Python_str_AsChar(obj); } } if (psize) *psize = len + 1; -#if PY_VERSION_HEX>=0x03000000 - Py_XDECREF(obj); -#endif return SWIG_OK; } else { swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); @@ -3313,6 +3297,13 @@ SWIG_AsPtr_std_string (PyObject * obj, std::string **val) } +SWIGINTERNINLINE PyObject * +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + #include #if !defined(SWIG_NO_LLONG_MAX) # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) @@ -3339,11 +3330,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) } -SWIGINTERNINLINE PyObject * -SWIG_From_int (int value) -{ - return SWIG_From_long (value); -} + SWIGINTERN int @@ -3377,11 +3364,11 @@ SWIG_From_unsigned_SS_int (unsigned int value) } + #include #include #include #include #include - #include #include #include #include @@ -3392,253 +3379,21228 @@ SWIG_From_unsigned_SS_int (unsigned int value) #include #include -#ifdef __cplusplus -extern "C" { -#endif -SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} +namespace swig { + template + struct noconst_traits { + typedef Type noconst_type; + }; -SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); + template + struct noconst_traits { + typedef Type noconst_type; + }; + + /* + type categories + */ + struct pointer_category { }; + struct value_category { }; + + /* + General traits that provides type_name and type_info + */ + template struct traits { }; + + template + inline const char* type_name() { + return traits::noconst_type >::type_name(); } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; + + template + struct traits_info { + static swig_type_info *type_query(std::string name) { + name += " *"; + return SWIG_TypeQuery(name.c_str()); + } + static swig_type_info *type_info() { + static swig_type_info *info = type_query(type_name()); + return info; } + }; + + template + inline swig_type_info *type_info() { + return traits_info::type_info(); } - - resultobj = result; - return resultobj; -fail: - return NULL; + + /* + Partial specialization for pointers + */ + template struct traits { + typedef pointer_category category; + static std::string make_ptr_name(const char* name) { + std::string ptrname = name; + ptrname += " *"; + return ptrname; + } + static const char* type_name() { + static std::string name = make_ptr_name(swig::type_name()); + return name.c_str(); + } + }; + + template + struct traits_as { }; + + template + struct traits_check { }; + } -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - size_t arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - size_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); - } - arg2 = static_cast< size_t >(val2); - try { - result = (swig::SwigPyIterator *)(arg1)->incr(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; +namespace swig { + /* + Traits that provides the from method + */ + template struct traits_from_ptr { + static PyObject *from(Type *val, int owner = 0) { + return SWIG_NewPointerObj(val, type_info(), owner); } - } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} + }; + template struct traits_from { + static PyObject *from(const Type& val) { + return traits_from_ptr::from(new Type(val), 1); + } + }; -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + template struct traits_from { + static PyObject *from(Type* val) { + return traits_from_ptr::from(val, 0); + } + }; + + template struct traits_from { + static PyObject *from(const Type* val) { + return traits_from_ptr::from(const_cast(val), 0); + } + }; + + + template + inline PyObject *from(const Type& val) { + return traits_from::from(val); } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (swig::SwigPyIterator *)(arg1)->incr(); + + template + inline PyObject *from_ptr(Type* val, int owner) { + return traits_from_ptr::from(val, owner); } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; + + /* + Traits that provides the asval/as/check method + */ + template + struct traits_asptr { + static int asptr(PyObject *obj, Type **val) { + Type *p; + int res = SWIG_ConvertPtr(obj, (void**)&p, type_info(), 0); + if (SWIG_IsOK(res)) { + if (val) *val = p; + } + return res; } + }; + + template + inline int asptr(PyObject *obj, Type **vptr) { + return traits_asptr::asptr(obj, vptr); } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} + template + struct traits_asval { + static int asval(PyObject *obj, Type *val) { + if (val) { + Type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (!SWIG_IsOK(res)) return res; + if (p) { + typedef typename noconst_traits::noconst_type noconst_type; + *(const_cast(val)) = *p; + if (SWIG_IsNewObj(res)){ + delete p; + res = SWIG_DelNewMask(res); + } + return res; + } else { + return SWIG_ERROR; + } + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; -SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { - int argc; - PyObject *argv[3]; - int ii; + template struct traits_asval { + static int asval(PyObject *obj, Type **val) { + if (val) { + typedef typename noconst_traits::noconst_type noconst_type; + noconst_type *p = 0; + int res = traits_asptr::asptr(obj, &p); + if (SWIG_IsOK(res)) { + *(const_cast(val)) = p; + } + return res; + } else { + return traits_asptr::asptr(obj, (Type **)(0)); + } + } + }; - if (!PyTuple_Check(args)) SWIG_fail; - argc = (int)PyObject_Length(args); - for (ii = 0; (ii < argc) && (ii < 2); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); + template + inline int asval(PyObject *obj, Type *val) { + return traits_asval::asval(obj, val); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SwigPyIterator_incr__SWIG_1(self, args); + + template + struct traits_as { + static Type as(PyObject *obj, bool throw_error) { + Type v; + int res = asval(obj, &v); + if (!obj || !SWIG_IsOK(res)) { + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + } + return v; } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_size_t(argv[1], NULL); - _v = SWIG_CheckState(res); + }; + + template + struct traits_as { + static Type as(PyObject *obj, bool throw_error) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res) && v) { + if (SWIG_IsNewObj(res)) { + Type r(*v); + delete v; + return r; + } else { + return *v; + } + } else { + // Uninitialized return value, no Type() constructor required. + static Type *v_def = (Type*) malloc(sizeof(Type)); + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + memset(v_def,0,sizeof(Type)); + return *v_def; } - if (_v) { - return _wrap_SwigPyIterator_incr__SWIG_0(self, args); + } + }; + + template + struct traits_as { + static Type* as(PyObject *obj, bool throw_error) { + Type *v = 0; + int res = (obj ? traits_asptr::asptr(obj, &v) : SWIG_ERROR); + if (SWIG_IsOK(res)) { + return v; + } else { + if (!PyErr_Occurred()) { + SWIG_Error(SWIG_TypeError, swig::type_name()); + } + if (throw_error) throw std::invalid_argument("bad type"); + return 0; } } + }; + + template + inline Type as(PyObject *obj, bool te = false) { + return traits_as::category>::as(obj, te); + } + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + struct traits_check { + static bool check(PyObject *obj) { + int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR; + return SWIG_IsOK(res) ? true : false; + } + }; + + template + inline bool check(PyObject *obj) { + return traits_check::category>::check(obj); } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_incr'.\n" - " Possible C/C++ prototypes are:\n" - " incr(swig::SwigPyIterator *,size_t)\n" - " incr(swig::SwigPyIterator *)\n"); - return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; +#include + +namespace std { + template <> + struct less : public binary_function + { + bool + operator()(PyObject * v, PyObject *w) const + { + bool res; + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + res = PyObject_Compare(v, w) < 0; + /* This may fall into a case of inconsistent + eg. ObjA > ObjX > ObjB + but ObjA < ObjB + */ + if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) ) + { + /* Objects can't be compared, this mostly occured in Python 3.0 */ + /* Compare their ptr directly for a workaround */ + res = (v < w); + PyErr_Clear(); + } + SWIG_PYTHON_THREAD_END_BLOCK; + return res; + } + }; + + template <> + struct less : public binary_function + { + bool + operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const + { + return std::less()(v, w); + } + }; + + template <> + struct less : public binary_function + { + bool + operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const + { + return std::less()(v, w); + } + }; + +} + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return "PyObject *"; } + }; + + template <> struct traits_asval { + typedef PyObject * value_type; + static int asval(PyObject *obj, value_type *val) { + if (val) *val = obj; + return SWIG_OK; + } + }; + + template <> + struct traits_check { + static bool check(PyObject *) { + return true; + } + }; + + template <> struct traits_from { + typedef PyObject * value_type; + static PyObject *from(const value_type& val) { + Py_XINCREF(val); + return val; + } + }; + +} + +namespace swig { + inline size_t + check_index(ptrdiff_t i, size_t size, bool insert = false) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) + return (size_t) (i + size); + } else if ( (size_t) i < size ) { + return (size_t) i; + } else if (insert && ((size_t) i == size)) { + return size; + } + + throw std::out_of_range("index out of range"); + } + + inline size_t + slice_index(ptrdiff_t i, size_t size) { + if ( i < 0 ) { + if ((size_t) (-i) <= size) { + return (size_t) (i + size); + } else { + throw std::out_of_range("index out of range"); + } + } else { + return ( (size_t) i < size ) ? ((size_t) i) : size; + } + } + + template + inline typename Sequence::iterator + getpos(Sequence* self, Difference i) { + typename Sequence::iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline typename Sequence::const_iterator + cgetpos(const Sequence* self, Difference i) { + typename Sequence::const_iterator pos = self->begin(); + std::advance(pos, check_index(i,self->size())); + return pos; + } + + template + inline Sequence* + getslice(const Sequence* self, Difference i, Difference j) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size); + typename Sequence::size_type jj = swig::slice_index(j, size); + + if (jj > ii) { + typename Sequence::const_iterator vb = self->begin(); + typename Sequence::const_iterator ve = self->begin(); + std::advance(vb,ii); + std::advance(ve,jj); + return new Sequence(vb, ve); + } else { + return new Sequence(); + } + } + + template + inline void + setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size, true); + typename Sequence::size_type jj = swig::slice_index(j, size); + if (jj < ii) jj = ii; + size_t ssize = jj - ii; + if (ssize <= v.size()) { + typename Sequence::iterator sb = self->begin(); + typename InputSeq::const_iterator vmid = v.begin(); + std::advance(sb,ii); + std::advance(vmid, jj - ii); + self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end()); + } else { + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + self->insert(sb, v.begin(), v.end()); + } + } + + template + inline void + delslice(Sequence* self, Difference i, Difference j) { + typename Sequence::size_type size = self->size(); + typename Sequence::size_type ii = swig::check_index(i, size, true); + typename Sequence::size_type jj = swig::slice_index(j, size); + if (jj > ii) { + typename Sequence::iterator sb = self->begin(); + typename Sequence::iterator se = self->begin(); + std::advance(sb,ii); + std::advance(se,jj); + self->erase(sb,se); + } + } +} + + +#if defined(__SUNPRO_CC) && defined(_RWSTD_VER) +# if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL) +# define SWIG_STD_NOITERATOR_TRAITS_STL +# endif +#endif + +#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL) +#include +#else +namespace std { + template + struct iterator_traits { + typedef ptrdiff_t difference_type; + typedef typename Iterator::value_type value_type; + }; + + template + struct iterator_traits<__reverse_bi_iterator > { + typedef Distance difference_type; + typedef T value_type; + }; + + template + struct iterator_traits { + typedef T value_type; + typedef ptrdiff_t difference_type; + }; + + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) { + ++__first; ++__n; + } + return __n; + } +} +#endif + + +namespace swig { + template + class SwigPyIterator_T : public SwigPyIterator + { + public: + typedef OutIterator out_iterator; + typedef typename std::iterator_traits::value_type value_type; + typedef SwigPyIterator_T self_type; + + SwigPyIterator_T(out_iterator curr, PyObject *seq) + : SwigPyIterator(seq), current(curr) + { + } + + const out_iterator& get_current() const + { + return current; + } + + + bool equal (const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return (current == iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + ptrdiff_t distance(const SwigPyIterator &iter) const + { + const self_type *iters = dynamic_cast(&iter); + if (iters) { + return std::distance(current, iters->get_current()); + } else { + throw std::invalid_argument("bad iterator type"); + } + } + + protected: + out_iterator current; + }; + + template + struct from_oper + { + typedef const ValueType& argument_type; + typedef PyObject *result_type; + result_type operator()(argument_type v) const + { + return swig::from(v); + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorOpen_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorOpen_T self_type; + + SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq) + : SwigPyIterator_T(curr, seq) + { + } + + PyObject *value() const { + return from(static_cast(*(base::current))); + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + ++base::current; + } + return this; + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + --base::current; + } + return this; + } + }; + + template::value_type, + typename FromOper = from_oper > + class SwigPyIteratorClosed_T : public SwigPyIterator_T + { + public: + FromOper from; + typedef OutIterator out_iterator; + typedef ValueType value_type; + typedef SwigPyIterator_T base; + typedef SwigPyIteratorClosed_T self_type; + + SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq) + : SwigPyIterator_T(curr, seq), begin(first), end(last) + { + } + + PyObject *value() const { + if (base::current == end) { + throw stop_iteration(); + } else { + return from(static_cast(*(base::current))); + } + } + + SwigPyIterator *copy() const + { + return new self_type(*this); + } + + SwigPyIterator *incr(size_t n = 1) + { + while (n--) { + if (base::current == end) { + throw stop_iteration(); + } else { + ++base::current; + } + } + return this; + } + + SwigPyIterator *decr(size_t n = 1) + { + while (n--) { + if (base::current == begin) { + throw stop_iteration(); + } else { + --base::current; + } + } + return this; + } + + private: + out_iterator begin; + out_iterator end; + }; + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0) + { + return new SwigPyIteratorClosed_T(current, begin, end, seq); + } + + template + inline SwigPyIterator* + make_output_iterator(const OutIter& current, PyObject *seq = 0) + { + return new SwigPyIteratorOpen_T(current, seq); + } +} + + +namespace swig +{ + template + struct SwigPySequence_Ref + { + SwigPySequence_Ref(PyObject* seq, int index) + : _seq(seq), _index(index) + { + } + + operator T () const + { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index); + try { + return swig::as(item, true); + } catch (std::exception& e) { + char msg[1024]; + sprintf(msg, "in sequence element %d ", _index); + if (!PyErr_Occurred()) { + ::SWIG_Error(SWIG_TypeError, swig::type_name()); + } + SWIG_Python_AddErrorMsg(msg); + SWIG_Python_AddErrorMsg(e.what()); + throw; + } + } + + SwigPySequence_Ref& operator=(const T& v) + { + PySequence_SetItem(_seq, _index, swig::from(v)); + return *this; + } + + private: + PyObject* _seq; + int _index; + }; + + template + struct SwigPySequence_ArrowProxy + { + SwigPySequence_ArrowProxy(const T& x): m_value(x) {} + const T* operator->() const { return &m_value; } + operator const T*() const { return &m_value; } + T m_value; + }; + + template + struct SwigPySequence_InputIterator + { + typedef SwigPySequence_InputIterator self; + + typedef std::random_access_iterator_tag iterator_category; + typedef Reference reference; + typedef T value_type; + typedef T* pointer; + typedef int difference_type; + + SwigPySequence_InputIterator() + { + } + + SwigPySequence_InputIterator(PyObject* seq, int index) + : _seq(seq), _index(index) + { + } + + reference operator*() const + { + return reference(_seq, _index); + } + + SwigPySequence_ArrowProxy + operator->() const { + return SwigPySequence_ArrowProxy(operator*()); + } + + bool operator==(const self& ri) const + { + return (_index == ri._index) && (_seq == ri._seq); + } + + bool operator!=(const self& ri) const + { + return !(operator==(ri)); + } + + self& operator ++ () + { + ++_index; + return *this; + } + + self& operator -- () + { + --_index; + return *this; + } + + self& operator += (difference_type n) + { + _index += n; + return *this; + } + + self operator +(difference_type n) const + { + return self(_seq, _index + n); + } + + self& operator -= (difference_type n) + { + _index -= n; + return *this; + } + + self operator -(difference_type n) const + { + return self(_seq, _index - n); + } + + difference_type operator - (const self& ri) const + { + return _index - ri._index; + } + + bool operator < (const self& ri) const + { + return _index < ri._index; + } + + reference + operator[](difference_type n) const + { + return reference(_seq, _index + n); + } + + private: + PyObject* _seq; + difference_type _index; + }; + + template + struct SwigPySequence_Cont + { + typedef SwigPySequence_Ref reference; + typedef const SwigPySequence_Ref const_reference; + typedef T value_type; + typedef T* pointer; + typedef int difference_type; + typedef int size_type; + typedef const pointer const_pointer; + typedef SwigPySequence_InputIterator iterator; + typedef SwigPySequence_InputIterator const_iterator; + + SwigPySequence_Cont(PyObject* seq) : _seq(0) + { + if (!PySequence_Check(seq)) { + throw std::invalid_argument("a sequence is expected"); + } + _seq = seq; + Py_INCREF(_seq); + } + + ~SwigPySequence_Cont() + { + Py_XDECREF(_seq); + } + + size_type size() const + { + return static_cast(PySequence_Size(_seq)); + } + + bool empty() const + { + return size() == 0; + } + + iterator begin() + { + return iterator(_seq, 0); + } + + const_iterator begin() const + { + return const_iterator(_seq, 0); + } + + iterator end() + { + return iterator(_seq, size()); + } + + const_iterator end() const + { + return const_iterator(_seq, size()); + } + + reference operator[](difference_type n) + { + return reference(_seq, n); + } + + const_reference operator[](difference_type n) const + { + return const_reference(_seq, n); + } + + bool check(bool set_err = true) const + { + int s = size(); + for (int i = 0; i < s; ++i) { + swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i); + if (!swig::check(item)) { + if (set_err) { + char msg[1024]; + sprintf(msg, "in sequence element %d", i); + SWIG_Error(SWIG_RuntimeError, msg); + } + return false; + } + } + return true; + } + + private: + PyObject* _seq; + }; + +} + + +SWIGINTERN int +SWIG_AsCharArray(PyObject * obj, char *val, size_t size) +{ + char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; + int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); + if (SWIG_IsOK(res)) { + if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize; + if (csize <= size) { + if (val) { + if (csize) memcpy(val, cptr, csize*sizeof(char)); + if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); + } + if (alloc == SWIG_NEWOBJ) { + delete[] cptr; + res = SWIG_DelNewMask(res); + } + return res; + } + if (alloc == SWIG_NEWOBJ) delete[] cptr; + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_char (PyObject * obj, char *val) +{ + int res = SWIG_AsCharArray(obj, val, 1); + if (!SWIG_IsOK(res)) { + long v; + res = SWIG_AddCast(SWIG_AsVal_long (obj, &v)); + if (SWIG_IsOK(res)) { + if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) { + if (val) *val = static_cast< char >(v); + } else { + res = SWIG_OverflowError; + } + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_char (char c) +{ + return SWIG_FromCharPtrAndSize(&c,1); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"char"; } + }; + template <> struct traits_asval { + typedef char value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_char (obj, val); + } + }; + template <> struct traits_from { + typedef char value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_char (val); + } + }; +} + + +namespace swig { + template + inline void + assign(const SwigPySeq& swigpyseq, Seq* seq) { + // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented + typedef typename SwigPySeq::value_type value_type; + typename SwigPySeq::const_iterator it = swigpyseq.begin(); + for (;it != swigpyseq.end(); ++it) { + seq->insert(seq->end(),(value_type)(*it)); + } + } + + template + struct traits_asptr_stdseq { + typedef Seq sequence; + typedef T value_type; + + static int asptr(PyObject *obj, sequence **seq) { + if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) { + sequence *p; + if (::SWIG_ConvertPtr(obj,(void**)&p, + swig::type_info(),0) == SWIG_OK) { + if (seq) *seq = p; + return SWIG_OLDOBJ; + } + } else if (PySequence_Check(obj)) { + try { + SwigPySequence_Cont swigpyseq(obj); + if (seq) { + sequence *pseq = new sequence(); + assign(swigpyseq, pseq); + *seq = pseq; + return SWIG_NEWOBJ; + } else { + return swigpyseq.check() ? SWIG_OK : SWIG_ERROR; + } + } catch (std::exception& e) { + if (seq) { + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, e.what()); + } + } + return SWIG_ERROR; + } + } + return SWIG_ERROR; + } + }; + + template + struct traits_from_stdseq { + typedef Seq sequence; + typedef T value_type; + typedef typename Seq::size_type size_type; + typedef typename sequence::const_iterator const_iterator; + + static PyObject *from(const sequence& seq) { +#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS + swig_type_info *desc = swig::type_info(); + if (desc && desc->clientdata) { + return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN); + } +#endif + size_type size = seq.size(); + if (size <= (size_type)INT_MAX) { + PyObject *obj = PyTuple_New((int)size); + int i = 0; + for (const_iterator it = seq.begin(); + it != seq.end(); ++it, ++i) { + PyTuple_SetItem(obj,i,swig::from(*it)); + } + return obj; + } else { + PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python"); + return NULL; + } + } + }; +} + + + namespace swig { + template + struct traits_asptr > { + static int asptr(PyObject *obj, std::vector **vec) { + return traits_asptr_stdseq >::asptr(obj, vec); + } + }; + + template + struct traits_from > { + static PyObject *from(const std::vector& vec) { + return traits_from_stdseq >::from(vec); + } + }; + } + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "char" "," "std::allocator< char >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_char_Sg__iterator(std::vector< char > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_char_Sg____nonzero__(std::vector< char > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_char_Sg____bool__(std::vector< char > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< char >::size_type std_vector_Sl_char_Sg____len__(std::vector< char > const *self){ + return self->size(); + } + +SWIGINTERNINLINE PyObject * +SWIG_From_size_t (size_t value) +{ + return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value)); +} + +SWIGINTERN std::vector< char >::value_type std_vector_Sl_char_Sg__pop(std::vector< char > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< char,std::allocator< char > > *std_vector_Sl_char_Sg____getslice__(std::vector< char > *self,std::vector< char >::difference_type i,std::vector< char >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_char_Sg____setslice__(std::vector< char > *self,std::vector< char >::difference_type i,std::vector< char >::difference_type j,std::vector< char,std::allocator< char > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_char_Sg____delslice__(std::vector< char > *self,std::vector< char >::difference_type i,std::vector< char >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_char_Sg____delitem____SWIG_0(std::vector< char > *self,std::vector< char >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< char,std::allocator< char > > *std_vector_Sl_char_Sg____getitem____SWIG_0(std::vector< char > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_char_Sg____setitem____SWIG_0(std::vector< char > *self,PySliceObject *slice,std::vector< char,std::allocator< char > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_char_Sg____delitem____SWIG_1(std::vector< char > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< char >::value_type const &std_vector_Sl_char_Sg____getitem____SWIG_1(std::vector< char > const *self,std::vector< char >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_char_Sg____setitem____SWIG_1(std::vector< char > *self,std::vector< char >::difference_type i,std::vector< char >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_char_Sg__append(std::vector< char > *self,std::vector< char >::value_type const &x){ + self->push_back(x); + } + +SWIGINTERN int +SWIG_AsVal_short (PyObject * obj, short *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < SHRT_MIN || v > SHRT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< short >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_short (short value) +{ + return SWIG_From_long (value); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"short"; } + }; + template <> struct traits_asval { + typedef short value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_short (obj, val); + } + }; + template <> struct traits_from { + typedef short value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_short (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "short" "," "std::allocator< short >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_short_Sg__iterator(std::vector< short > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_short_Sg____nonzero__(std::vector< short > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_short_Sg____bool__(std::vector< short > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< short >::size_type std_vector_Sl_short_Sg____len__(std::vector< short > const *self){ + return self->size(); + } +SWIGINTERN std::vector< short >::value_type std_vector_Sl_short_Sg__pop(std::vector< short > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< short,std::allocator< short > > *std_vector_Sl_short_Sg____getslice__(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_short_Sg____setslice__(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j,std::vector< short,std::allocator< short > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_short_Sg____delslice__(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_short_Sg____delitem____SWIG_0(std::vector< short > *self,std::vector< short >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< short,std::allocator< short > > *std_vector_Sl_short_Sg____getitem____SWIG_0(std::vector< short > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_short_Sg____setitem____SWIG_0(std::vector< short > *self,PySliceObject *slice,std::vector< short,std::allocator< short > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_short_Sg____delitem____SWIG_1(std::vector< short > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< short >::value_type const &std_vector_Sl_short_Sg____getitem____SWIG_1(std::vector< short > const *self,std::vector< short >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_short_Sg____setitem____SWIG_1(std::vector< short > *self,std::vector< short >::difference_type i,std::vector< short >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_short_Sg__append(std::vector< short > *self,std::vector< short >::value_type const &x){ + self->push_back(x); + } + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"int"; } + }; + template <> struct traits_asval { + typedef int value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_int (obj, val); + } + }; + template <> struct traits_from { + typedef int value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_int (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "int" "," "std::allocator< int >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){ + return self->size(); + } +SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_int_Sg____setslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){ + self->push_back(x); + } + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"long"; } + }; + template <> struct traits_asval { + typedef long value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_long (obj, val); + } + }; + template <> struct traits_from { + typedef long value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_long (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "long" "," "std::allocator< long >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_long_Sg__iterator(std::vector< long > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_long_Sg____nonzero__(std::vector< long > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_long_Sg____bool__(std::vector< long > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< long >::size_type std_vector_Sl_long_Sg____len__(std::vector< long > const *self){ + return self->size(); + } +SWIGINTERN std::vector< long >::value_type std_vector_Sl_long_Sg__pop(std::vector< long > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< long,std::allocator< long > > *std_vector_Sl_long_Sg____getslice__(std::vector< long > *self,std::vector< long >::difference_type i,std::vector< long >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_long_Sg____setslice__(std::vector< long > *self,std::vector< long >::difference_type i,std::vector< long >::difference_type j,std::vector< long,std::allocator< long > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_long_Sg____delslice__(std::vector< long > *self,std::vector< long >::difference_type i,std::vector< long >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_long_Sg____delitem____SWIG_0(std::vector< long > *self,std::vector< long >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< long,std::allocator< long > > *std_vector_Sl_long_Sg____getitem____SWIG_0(std::vector< long > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_long_Sg____setitem____SWIG_0(std::vector< long > *self,PySliceObject *slice,std::vector< long,std::allocator< long > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_long_Sg____delitem____SWIG_1(std::vector< long > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< long >::value_type const &std_vector_Sl_long_Sg____getitem____SWIG_1(std::vector< long > const *self,std::vector< long >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_long_Sg____setitem____SWIG_1(std::vector< long > *self,std::vector< long >::difference_type i,std::vector< long >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_long_Sg__append(std::vector< long > *self,std::vector< long >::value_type const &x){ + self->push_back(x); + } + +SWIGINTERN int +SWIG_AsVal_float (PyObject * obj, float *val) +{ + double v; + int res = SWIG_AsVal_double (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < -FLT_MAX || v > FLT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< float >(v); + } + } + return res; +} + + + #define SWIG_From_double PyFloat_FromDouble + + +SWIGINTERNINLINE PyObject * +SWIG_From_float (float value) +{ + return SWIG_From_double (value); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"float"; } + }; + template <> struct traits_asval { + typedef float value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_float (obj, val); + } + }; + template <> struct traits_from { + typedef float value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_float (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "float" "," "std::allocator< float >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_float_Sg__iterator(std::vector< float > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_float_Sg____nonzero__(std::vector< float > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_float_Sg____bool__(std::vector< float > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< float >::size_type std_vector_Sl_float_Sg____len__(std::vector< float > const *self){ + return self->size(); + } +SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg__pop(std::vector< float > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< float,std::allocator< float > > *std_vector_Sl_float_Sg____getslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_float_Sg____setslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j,std::vector< float,std::allocator< float > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_float_Sg____delslice__(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_float_Sg____delitem____SWIG_0(std::vector< float > *self,std::vector< float >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< float,std::allocator< float > > *std_vector_Sl_float_Sg____getitem____SWIG_0(std::vector< float > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_float_Sg____setitem____SWIG_0(std::vector< float > *self,PySliceObject *slice,std::vector< float,std::allocator< float > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_float_Sg____delitem____SWIG_1(std::vector< float > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< float >::value_type const &std_vector_Sl_float_Sg____getitem____SWIG_1(std::vector< float > const *self,std::vector< float >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_float_Sg____setitem____SWIG_1(std::vector< float > *self,std::vector< float >::difference_type i,std::vector< float >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_float_Sg__append(std::vector< float > *self,std::vector< float >::value_type const &x){ + self->push_back(x); + } + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"double"; } + }; + template <> struct traits_asval { + typedef double value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_double (obj, val); + } + }; + template <> struct traits_from { + typedef double value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_double (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "double" "," "std::allocator< double >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){ + return self->size(); + } +SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_double_Sg____setslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){ + self->push_back(x); + } + +SWIGINTERN int +SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) +{ + unsigned long v; + int res = SWIG_AsVal_unsigned_SS_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v > UCHAR_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< unsigned char >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_char (unsigned char value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"unsigned char"; } + }; + template <> struct traits_asval { + typedef unsigned char value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_unsigned_SS_char (obj, val); + } + }; + template <> struct traits_from { + typedef unsigned char value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_unsigned_SS_char (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "unsigned char" "," "std::allocator< unsigned char >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_unsigned_SS_char_Sg__iterator(std::vector< unsigned char > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_char_Sg____nonzero__(std::vector< unsigned char > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_char_Sg____bool__(std::vector< unsigned char > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< unsigned char >::size_type std_vector_Sl_unsigned_SS_char_Sg____len__(std::vector< unsigned char > const *self){ + return self->size(); + } +SWIGINTERN std::vector< unsigned char >::value_type std_vector_Sl_unsigned_SS_char_Sg__pop(std::vector< unsigned char > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_unsigned_SS_char_Sg____getslice__(std::vector< unsigned char > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setslice__(std::vector< unsigned char > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j,std::vector< unsigned char,std::allocator< unsigned char > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____delslice__(std::vector< unsigned char > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_0(std::vector< unsigned char > *self,std::vector< unsigned char >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< unsigned char,std::allocator< unsigned char > > *std_vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_0(std::vector< unsigned char > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_0(std::vector< unsigned char > *self,PySliceObject *slice,std::vector< unsigned char,std::allocator< unsigned char > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____delitem____SWIG_1(std::vector< unsigned char > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< unsigned char >::value_type const &std_vector_Sl_unsigned_SS_char_Sg____getitem____SWIG_1(std::vector< unsigned char > const *self,std::vector< unsigned char >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setitem____SWIG_1(std::vector< unsigned char > *self,std::vector< unsigned char >::difference_type i,std::vector< unsigned char >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg__append(std::vector< unsigned char > *self,std::vector< unsigned char >::value_type const &x){ + self->push_back(x); + } + +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); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_short (unsigned short value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"unsigned short"; } + }; + template <> struct traits_asval { + typedef unsigned short value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_unsigned_SS_short (obj, val); + } + }; + template <> struct traits_from { + typedef unsigned short value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_unsigned_SS_short (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "unsigned short" "," "std::allocator< unsigned short >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_unsigned_SS_short_Sg__iterator(std::vector< unsigned short > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_short_Sg____nonzero__(std::vector< unsigned short > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_short_Sg____bool__(std::vector< unsigned short > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< unsigned short >::size_type std_vector_Sl_unsigned_SS_short_Sg____len__(std::vector< unsigned short > const *self){ + return self->size(); + } +SWIGINTERN std::vector< unsigned short >::value_type std_vector_Sl_unsigned_SS_short_Sg__pop(std::vector< unsigned short > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< unsigned short,std::allocator< unsigned short > > *std_vector_Sl_unsigned_SS_short_Sg____getslice__(std::vector< unsigned short > *self,std::vector< unsigned short >::difference_type i,std::vector< unsigned short >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____setslice__(std::vector< unsigned short > *self,std::vector< unsigned short >::difference_type i,std::vector< unsigned short >::difference_type j,std::vector< unsigned short,std::allocator< unsigned short > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____delslice__(std::vector< unsigned short > *self,std::vector< unsigned short >::difference_type i,std::vector< unsigned short >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____delitem____SWIG_0(std::vector< unsigned short > *self,std::vector< unsigned short >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< unsigned short,std::allocator< unsigned short > > *std_vector_Sl_unsigned_SS_short_Sg____getitem____SWIG_0(std::vector< unsigned short > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____setitem____SWIG_0(std::vector< unsigned short > *self,PySliceObject *slice,std::vector< unsigned short,std::allocator< unsigned short > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____delitem____SWIG_1(std::vector< unsigned short > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< unsigned short >::value_type const &std_vector_Sl_unsigned_SS_short_Sg____getitem____SWIG_1(std::vector< unsigned short > const *self,std::vector< unsigned short >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg____setitem____SWIG_1(std::vector< unsigned short > *self,std::vector< unsigned short >::difference_type i,std::vector< unsigned short >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_unsigned_SS_short_Sg__append(std::vector< unsigned short > *self,std::vector< unsigned short >::value_type const &x){ + self->push_back(x); + } + +namespace swig { + template <> struct traits { + typedef value_category category; + static const char* type_name() { return"unsigned int"; } + }; + template <> struct traits_asval { + typedef unsigned int value_type; + static int asval(PyObject *obj, value_type *val) { + return SWIG_AsVal_unsigned_SS_int (obj, val); + } + }; + template <> struct traits_from { + typedef unsigned int value_type; + static PyObject *from(const value_type& val) { + return SWIG_From_unsigned_SS_int (val); + } + }; +} + + + namespace swig { + template <> struct traits > > { + typedef pointer_category category; + static const char* type_name() { + return "std::vector<" "unsigned int" "," "std::allocator< unsigned int >" " >"; + } + }; + } + +SWIGINTERN swig::SwigPyIterator *std_vector_Sl_unsigned_SS_int_Sg__iterator(std::vector< unsigned int > *self,PyObject **PYTHON_SELF){ + return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____nonzero__(std::vector< unsigned int > const *self){ + return !(self->empty()); + } +SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____bool__(std::vector< unsigned int > const *self){ + return !(self->empty()); + } +SWIGINTERN std::vector< unsigned int >::size_type std_vector_Sl_unsigned_SS_int_Sg____len__(std::vector< unsigned int > const *self){ + return self->size(); + } +SWIGINTERN std::vector< unsigned int >::value_type std_vector_Sl_unsigned_SS_int_Sg__pop(std::vector< unsigned int > *self){ + if (self->size() == 0) + throw std::out_of_range("pop from empty container"); + std::vector >::value_type x = self->back(); + self->pop_back(); + return x; + } +SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){ + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j,std::vector< unsigned int,std::allocator< unsigned int > > const &v){ + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){ + swig::delslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i){ + self->erase(swig::getpos(self,i)); + } +SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(std::vector< unsigned int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return NULL; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + return swig::getslice(self, i, j); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(std::vector< unsigned int > *self,PySliceObject *slice,std::vector< unsigned int,std::allocator< unsigned int > > const &v){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::setslice(self, i, j, v); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(std::vector< unsigned int > *self,PySliceObject *slice){ + Py_ssize_t i, j, step; + if( !PySlice_Check(slice) ) { + SWIG_Error(SWIG_TypeError, "Slice object expected."); + return; + } + PySlice_GetIndices(slice, self->size(), &i, &j, &step); + swig::delslice(self, i,j); + } +SWIGINTERN std::vector< unsigned int >::value_type const &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(std::vector< unsigned int > const *self,std::vector< unsigned int >::difference_type i){ + return *(swig::cgetpos(self, i)); + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::value_type const &x){ + *(swig::getpos(self,i)) = x; + } +SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__append(std::vector< unsigned int > *self,std::vector< unsigned int >::value_type const &x){ + self->push_back(x); + } +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->incr(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_incr__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_incr'.\n" + " Possible C/C++ prototypes are:\n" + " incr(swig::SwigPyIterator *,size_t)\n" + " incr(swig::SwigPyIterator *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + size_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); + } + arg2 = static_cast< size_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (swig::SwigPyIterator *)(arg1)->decr(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator_decr__SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_decr'.\n" + " Possible C/C++ prototypes are:\n" + " decr(swig::SwigPyIterator *,size_t)\n" + " decr(swig::SwigPyIterator *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + ptrdiff_t result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + try { + result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); + } + catch(std::invalid_argument &_e) { + SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + } + + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->next(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->__next__(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + try { + result = (PyObject *)(arg1)->previous(); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)(arg1)->advance(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + { + swig::SwigPyIterator &_result_ref = (arg1)->operator +=(arg2); + result = (swig::SwigPyIterator *) &_result_ref; + } + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + { + swig::SwigPyIterator &_result_ref = (arg1)->operator -=(arg2); + result = (swig::SwigPyIterator *) &_result_ref; + } + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + ptrdiff_t arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + swig::SwigPyIterator *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); + } + arg2 = static_cast< ptrdiff_t >(val2); + try { + result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); + } + catch(swig::stop_iteration &_e) { + { + (void)_e; + SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); + SWIG_fail; + } + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - size_t arg2 ; + swig::SwigPyIterator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + ptrdiff_t result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + } + arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + } + arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); + resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SwigPyIterator___sub____SWIG_0(self, args); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfAttribute *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (XdmfAttribute *)((boost::shared_ptr< XdmfAttribute > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfAttributePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfAttributePtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfAttribute > *)new boost::shared_ptr< XdmfAttribute >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfAttributePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfAttributePtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfAttributePtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfAttribute > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute >(static_cast< const boost::shared_ptr< XdmfAttribute >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setName",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (*arg1)->setName((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getAttributeType(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + XdmfAttributeType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setAttributeType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeType * >(argp2); + (*arg1)->setAttributeType((XdmfAttributeType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeTypeAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getAttributeTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeCenter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeCenter" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getAttributeCenter(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + XdmfAttributeCenter *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setAttributeCenter",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeCenter * >(argp2); + (*arg1)->setAttributeCenter((XdmfAttributeCenter const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeCenterAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeCenterAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeCenterAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getAttributeCenterAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + boost::shared_ptr< XdmfArray > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setArray",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } else { + boost::shared_ptr< XdmfArray > * temp = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setArray(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfArray const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray const >(static_cast< const boost::shared_ptr< XdmfArray const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getArray(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfAttribute_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfAttributePtr_getArray__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfAttributePtr_getArray__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfAttributePtr_getArray'.\n" + " Possible C/C++ prototypes are:\n" + " getArray(boost::shared_ptr< XdmfAttribute > *)\n" + " getArray(boost::shared_ptr< XdmfAttribute > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *XdmfAttributePtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfArray *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (XdmfArray *)((boost::shared_ptr< XdmfArray > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfArray, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfArrayPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfArrayPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfArray > *)new boost::shared_ptr< XdmfArray >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfArrayPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfArrayPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfArrayPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (*arg1)->getType(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getHDF5Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + hid_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getHDF5Type",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getHDF5Type" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (*arg1)->getHDF5Type(); + resultobj = SWIG_NewPointerObj((new hid_t(static_cast< const hid_t& >(result))), SWIGTYPE_p_hid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getPrecision",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getPrecision" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (int)(*arg1)->getPrecision(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getSize" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (int)(*arg1)->getSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getValues",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (*arg1)->getValues(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_getValuesPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + void *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_getValuesPointer",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_getValuesPointer" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (void *)(*arg1)->getValuesPointer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArrayPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< char,std::allocator< char > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< char,std::allocator< char > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< char,std::allocator< char > > &""'"); + } + arg2 = reinterpret_cast< std::vector< char,std::allocator< char > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< short,std::allocator< short > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< short,std::allocator< short > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< short,std::allocator< short > > &""'"); + } + arg2 = reinterpret_cast< std::vector< short,std::allocator< short > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< int,std::allocator< int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); + } + arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< long,std::allocator< long > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< long,std::allocator< long > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< long,std::allocator< long > > &""'"); + } + arg2 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< float,std::allocator< float > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< float,std::allocator< float > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< float,std::allocator< float > > &""'"); + } + arg2 = reinterpret_cast< std::vector< float,std::allocator< float > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_26(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_27(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< double,std::allocator< double > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > &""'"); + } + arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_28(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_29(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_30(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_31(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< unsigned char,std::allocator< unsigned char > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned char,std::allocator< unsigned char > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_33(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_34(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_35(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< unsigned short,std::allocator< unsigned short > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned short,std::allocator< unsigned short > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_36(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArrayPtr_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_37(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArrayPtr_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_38(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArrayPtr_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArrayPtr_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArrayPtr_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues__SWIG_39(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > *arg1 = (boost::shared_ptr< XdmfArray > *) 0 ; + std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArrayPtr_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArrayPtr_setValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfArray > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArrayPtr_setValues" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2); + (*arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArrayPtr_setValues(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 6); 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_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_7(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_11(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_15(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_19(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_23(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_27(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_31(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_35(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_39(self, args); + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_14(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_26(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_10(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_30(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_18(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_34(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_38(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_22(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_6(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_29(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_21(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_9(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_33(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_17(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_25(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_37(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_13(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_5(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_24(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_32(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_12(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_20(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_16(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_36(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_28(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_8(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArrayPtr_setValues__SWIG_4(self, args); + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfArrayPtr_setValues'.\n" + " Possible C/C++ prototypes are:\n" + " setValues< char >(boost::shared_ptr< XdmfArray > *,int,char *,int,int,int)\n" + " setValues< char >(boost::shared_ptr< XdmfArray > *,int,char *,int,int)\n" + " setValues< char >(boost::shared_ptr< XdmfArray > *,int,char *,int)\n" + " setValues< char >(boost::shared_ptr< XdmfArray > *,std::vector< char,std::allocator< char > > &)\n" + " setValues< short >(boost::shared_ptr< XdmfArray > *,int,short *,int,int,int)\n" + " setValues< short >(boost::shared_ptr< XdmfArray > *,int,short *,int,int)\n" + " setValues< short >(boost::shared_ptr< XdmfArray > *,int,short *,int)\n" + " setValues< short >(boost::shared_ptr< XdmfArray > *,std::vector< short,std::allocator< short > > &)\n" + " setValues< int >(boost::shared_ptr< XdmfArray > *,int,int *,int,int,int)\n" + " setValues< int >(boost::shared_ptr< XdmfArray > *,int,int *,int,int)\n" + " setValues< int >(boost::shared_ptr< XdmfArray > *,int,int *,int)\n" + " setValues< int >(boost::shared_ptr< XdmfArray > *,std::vector< int,std::allocator< int > > &)\n" + " setValues< long >(boost::shared_ptr< XdmfArray > *,int,long *,int,int,int)\n" + " setValues< long >(boost::shared_ptr< XdmfArray > *,int,long *,int,int)\n" + " setValues< long >(boost::shared_ptr< XdmfArray > *,int,long *,int)\n" + " setValues< long >(boost::shared_ptr< XdmfArray > *,std::vector< long,std::allocator< long > > &)\n" + " setValues< float >(boost::shared_ptr< XdmfArray > *,int,float *,int,int,int)\n" + " setValues< float >(boost::shared_ptr< XdmfArray > *,int,float *,int,int)\n" + " setValues< float >(boost::shared_ptr< XdmfArray > *,int,float *,int)\n" + " setValues< float >(boost::shared_ptr< XdmfArray > *,std::vector< float,std::allocator< float > > &)\n" + " setValues< double >(boost::shared_ptr< XdmfArray > *,int,double *,int,int,int)\n" + " setValues< double >(boost::shared_ptr< XdmfArray > *,int,double *,int,int)\n" + " setValues< double >(boost::shared_ptr< XdmfArray > *,int,double *,int)\n" + " setValues< double >(boost::shared_ptr< XdmfArray > *,std::vector< double,std::allocator< double > > &)\n" + " setValues< unsigned char >(boost::shared_ptr< XdmfArray > *,int,unsigned char *,int,int,int)\n" + " setValues< unsigned char >(boost::shared_ptr< XdmfArray > *,int,unsigned char *,int,int)\n" + " setValues< unsigned char >(boost::shared_ptr< XdmfArray > *,int,unsigned char *,int)\n" + " setValues< unsigned char >(boost::shared_ptr< XdmfArray > *,std::vector< unsigned char,std::allocator< unsigned char > > &)\n" + " setValues< unsigned short >(boost::shared_ptr< XdmfArray > *,int,unsigned short *,int,int,int)\n" + " setValues< unsigned short >(boost::shared_ptr< XdmfArray > *,int,unsigned short *,int,int)\n" + " setValues< unsigned short >(boost::shared_ptr< XdmfArray > *,int,unsigned short *,int)\n" + " setValues< unsigned short >(boost::shared_ptr< XdmfArray > *,std::vector< unsigned short,std::allocator< unsigned short > > &)\n" + " setValues< unsigned int >(boost::shared_ptr< XdmfArray > *,int,unsigned int *,int,int,int)\n" + " setValues< unsigned int >(boost::shared_ptr< XdmfArray > *,int,unsigned int *,int,int)\n" + " setValues< unsigned int >(boost::shared_ptr< XdmfArray > *,int,unsigned int *,int)\n" + " setValues< unsigned int >(boost::shared_ptr< XdmfArray > *,std::vector< unsigned int,std::allocator< unsigned int > > &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *XdmfArrayPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfDataItem *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + result = (XdmfDataItem *)((boost::shared_ptr< XdmfDataItem > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfDataItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfDataItemPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfDataItem > *)new boost::shared_ptr< XdmfDataItem >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfDataItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDataItemPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDataItemPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_setArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + boost::shared_ptr< XdmfArray > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDataItemPtr_setArray",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_setArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDataItemPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDataItemPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } else { + boost::shared_ptr< XdmfArray > * temp = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setArray(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_getArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_getArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfArray const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray const >(static_cast< const boost::shared_ptr< XdmfArray const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_getArray(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfDataItem_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfDataItemPtr_getArray__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfDataItemPtr_getArray__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDataItemPtr_getArray'.\n" + " Possible C/C++ prototypes are:\n" + " getArray(boost::shared_ptr< XdmfDataItem > *)\n" + " getArray(boost::shared_ptr< XdmfDataItem > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDataItemPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDataItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDataItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfDataItemPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfDomain *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + result = (XdmfDomain *)((boost::shared_ptr< XdmfDomain > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDomain, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfDomainPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfDomainPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfDomain > *)new boost::shared_ptr< XdmfDomain >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfDomainPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDomainPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDomainPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfDomain > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfDomain >(static_cast< const boost::shared_ptr< XdmfDomain >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + boost::shared_ptr< XdmfGrid > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_insert",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_insert" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomainPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomainPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); + } else { + boost::shared_ptr< XdmfGrid > * temp = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->insert(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + boost::shared_ptr< XdmfGrid > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_getGrid",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getGrid" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomainPtr_getGrid" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (*arg1)->getGrid(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid >(static_cast< const boost::shared_ptr< XdmfGrid >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfGrid const > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_getGrid",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getGrid" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomainPtr_getGrid" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (*arg1)->getGrid(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid const >(static_cast< const boost::shared_ptr< XdmfGrid const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_boost__shared_ptrT_XdmfDomain_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfDomainPtr_getGrid__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfDomainPtr_getGrid__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDomainPtr_getGrid'.\n" + " Possible C/C++ prototypes are:\n" + " getGrid(boost::shared_ptr< XdmfDomain > *,unsigned int)\n" + " getGrid(boost::shared_ptr< XdmfDomain > const *,unsigned int)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getNumberOfGrids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_getNumberOfGrids",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getNumberOfGrids" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + result = (unsigned int)(*arg1)->getNumberOfGrids(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomainPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomainPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomainPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfDomainPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfGeometry *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (XdmfGeometry *)((boost::shared_ptr< XdmfGeometry > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfGeometryPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfGeometryPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfGeometry > *)new boost::shared_ptr< XdmfGeometry >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfGeometryPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfGeometryPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfGeometryPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfGeometry > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getGeometryType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->getGeometryType(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_setGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryPtr_setGeometryType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + (*arg1)->setGeometryType((XdmfGeometryType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getGeometryTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getGeometryTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getGeometryTypeAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->getGeometryTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getDimensions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getDimensions" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (int)(*arg1)->getDimensions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_setArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + boost::shared_ptr< XdmfArray > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryPtr_setArray",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_setArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } else { + boost::shared_ptr< XdmfArray > * temp = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setArray(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfArray const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray const >(static_cast< const boost::shared_ptr< XdmfArray const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getArray(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfGeometry_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGeometryPtr_getArray__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGeometryPtr_getArray__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGeometryPtr_getArray'.\n" + " Possible C/C++ prototypes are:\n" + " getArray(boost::shared_ptr< XdmfGeometry > *)\n" + " getArray(boost::shared_ptr< XdmfGeometry > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *XdmfGeometryPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGridPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfGrid *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (XdmfGrid *)((boost::shared_ptr< XdmfGrid > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGrid, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfGridPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfGridPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfGrid > *)new boost::shared_ptr< XdmfGrid >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfGridPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfGridPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfGridPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfGrid > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid >(static_cast< const boost::shared_ptr< XdmfGrid >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfGeometry > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getGeometry",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getGeometry" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->getGeometry(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfGeometry const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getGeometry",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getGeometry" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->getGeometry(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry const >(static_cast< const boost::shared_ptr< XdmfGeometry const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getGeometry(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGridPtr_getGeometry__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGridPtr_getGeometry__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGridPtr_getGeometry'.\n" + " Possible C/C++ prototypes are:\n" + " getGeometry(boost::shared_ptr< XdmfGrid > *)\n" + " getGeometry(boost::shared_ptr< XdmfGrid > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_setGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + boost::shared_ptr< XdmfGeometry > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_setGeometry",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_setGeometry" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGridPtr_setGeometry" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGeometry >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGridPtr_setGeometry" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGeometry >""'"); + } else { + boost::shared_ptr< XdmfGeometry > * temp = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setGeometry(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfTopology > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getTopology",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getTopology" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->getTopology(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology >(static_cast< const boost::shared_ptr< XdmfTopology >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfTopology const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getTopology",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getTopology" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->getTopology(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology const >(static_cast< const boost::shared_ptr< XdmfTopology const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getTopology(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGridPtr_getTopology__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGridPtr_getTopology__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGridPtr_getTopology'.\n" + " Possible C/C++ prototypes are:\n" + " getTopology(boost::shared_ptr< XdmfGrid > *)\n" + " getTopology(boost::shared_ptr< XdmfGrid > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_setTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + boost::shared_ptr< XdmfTopology > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_setTopology",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_setTopology" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGridPtr_setTopology" "', argument " "2"" of type '" "boost::shared_ptr< XdmfTopology >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGridPtr_setTopology" "', argument " "2"" of type '" "boost::shared_ptr< XdmfTopology >""'"); + } else { + boost::shared_ptr< XdmfTopology > * temp = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setTopology(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_setName",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_setName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGridPtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGridPtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (*arg1)->setName((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + boost::shared_ptr< XdmfAttribute > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_insert",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_insert" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGridPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfAttribute >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGridPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfAttribute >""'"); + } else { + boost::shared_ptr< XdmfAttribute > * temp = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->insert(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + boost::shared_ptr< XdmfAttribute > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_getAttribute",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getAttribute" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfGridPtr_getAttribute" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (*arg1)->getAttribute(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute >(static_cast< const boost::shared_ptr< XdmfAttribute >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfAttribute const > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_getAttribute",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getAttribute" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfGridPtr_getAttribute" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (*arg1)->getAttribute(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute const >(static_cast< const boost::shared_ptr< XdmfAttribute const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getAttribute(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfGridPtr_getAttribute__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfGridPtr_getAttribute__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGridPtr_getAttribute'.\n" + " Possible C/C++ prototypes are:\n" + " getAttribute(boost::shared_ptr< XdmfGrid > *,unsigned int)\n" + " getAttribute(boost::shared_ptr< XdmfGrid > const *,unsigned int)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_getNumberOfAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_getNumberOfAttributes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_getNumberOfAttributes" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (unsigned int)(*arg1)->getNumberOfAttributes(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGridPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGridPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > *arg1 = (boost::shared_ptr< XdmfGrid > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGridPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGridPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGrid > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGridPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGridPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGridPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfItemPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfItem *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfItemPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItemPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + result = (XdmfItem *)((boost::shared_ptr< XdmfItem > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfItem, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfItemPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfItem > *)new boost::shared_ptr< XdmfItem >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfItemPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfItemPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfItemPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfItemPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItemPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfItemPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfItemPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItemPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfItemPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfObjPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfObject *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfObjPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfObjPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfObject > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfObject > * >(argp1); + result = (XdmfObject *)((boost::shared_ptr< XdmfObject > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfObject, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfObjPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfObject > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfObjPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfObject > *)new boost::shared_ptr< XdmfObject >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfObjPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfObjPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfObjPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfObject > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfObject > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfObjPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfObjPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfObjPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfObject > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfObject > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfObjPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfTopology *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (XdmfTopology *)((boost::shared_ptr< XdmfTopology > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfTopology, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfTopologyPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfTopologyPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfTopology > *)new boost::shared_ptr< XdmfTopology >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfTopologyPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfTopologyPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfTopologyPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfTopology > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology >(static_cast< const boost::shared_ptr< XdmfTopology >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getTopologyType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getTopologyType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->getTopologyType(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_setTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + XdmfTopologyType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopologyPtr_setTopologyType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_setTopologyType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfTopologyType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopologyPtr_setTopologyType" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopologyPtr_setTopologyType" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + arg2 = reinterpret_cast< XdmfTopologyType * >(argp2); + (*arg1)->setTopologyType((XdmfTopologyType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getNumberElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getNumberElements",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getNumberElements" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (int)(*arg1)->getNumberElements(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getTopologyTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getTopologyTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getTopologyTypeAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->getTopologyTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getNodesPerElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getNodesPerElement",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getNodesPerElement" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (int)(*arg1)->getNodesPerElement(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopologyPtr_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopologyPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopologyPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_setArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + boost::shared_ptr< XdmfArray > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopologyPtr_setArray",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_setArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopologyPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopologyPtr_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } else { + boost::shared_ptr< XdmfArray > * temp = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (*arg1)->setArray(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfArray const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getArray" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (*arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray const >(static_cast< const boost::shared_ptr< XdmfArray const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getArray(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_boost__shared_ptrT_XdmfTopology_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfTopologyPtr_getArray__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfTopologyPtr_getArray__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfTopologyPtr_getArray'.\n" + " Possible C/C++ prototypes are:\n" + " getArray(boost::shared_ptr< XdmfTopology > *)\n" + " getArray(boost::shared_ptr< XdmfTopology > const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *XdmfTopologyPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfVisitor *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (XdmfVisitor *)((boost::shared_ptr< XdmfVisitor > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfVisitorPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfVisitorPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfVisitor > *)new boost::shared_ptr< XdmfVisitor >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfVisitorPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfVisitorPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfVisitorPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfVisitor > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfVisitor >(static_cast< const boost::shared_ptr< XdmfVisitor >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfArray *arg2 = (XdmfArray *) (XdmfArray *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfArray const *const""'"); + } + arg2 = reinterpret_cast< XdmfArray * >(argp2); + (*arg1)->visit((XdmfArray const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfAttribute *arg2 = (XdmfAttribute *) (XdmfAttribute *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfAttribute const *const""'"); + } + arg2 = reinterpret_cast< XdmfAttribute * >(argp2); + (*arg1)->visit((XdmfAttribute const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfDomain *arg2 = (XdmfDomain *) (XdmfDomain *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfDomain const *const""'"); + } + arg2 = reinterpret_cast< XdmfDomain * >(argp2); + (*arg1)->visit((XdmfDomain const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfGeometry *arg2 = (XdmfGeometry *) (XdmfGeometry *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfGeometry const *const""'"); + } + arg2 = reinterpret_cast< XdmfGeometry * >(argp2); + (*arg1)->visit((XdmfGeometry const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfGrid *arg2 = (XdmfGrid *) (XdmfGrid *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfGrid const *const""'"); + } + arg2 = reinterpret_cast< XdmfGrid * >(argp2); + (*arg1)->visit((XdmfGrid const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + XdmfTopology *arg2 = (XdmfTopology *) (XdmfTopology *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_visit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitorPtr_visit" "', argument " "2"" of type '" "XdmfTopology const *const""'"); + } + arg2 = reinterpret_cast< XdmfTopology * >(argp2); + (*arg1)->visit((XdmfTopology const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_visit(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfAttribute, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfDomain, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_2(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfGeometry, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_3(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_4(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfTopology, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitorPtr_visit__SWIG_5(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfVisitorPtr_visit'.\n" + " Possible C/C++ prototypes are:\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfArray const *const)\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfAttribute const *const)\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfDomain const *const)\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfGeometry const *const)\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfGrid const *const)\n" + " visit(boost::shared_ptr< XdmfVisitor > *,XdmfTopology const *const)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_getLightDataLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr_getLightDataLimit",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_getLightDataLimit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (int)(*arg1)->getLightDataLimit(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_setLightDataLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitorPtr_setLightDataLimit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_setLightDataLimit" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfVisitorPtr_setLightDataLimit" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (*arg1)->setLightDataLimit(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfVisitorPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfObject_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfObject *arg1 = (XdmfObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfObject_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfObject, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfObject_printSelf" "', argument " "1"" of type '" "XdmfObject const *""'"); + } + arg1 = reinterpret_cast< XdmfObject * >(argp1); + result = ((XdmfObject const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfObject, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfItem_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfItem *arg1 = (XdmfItem *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfItem_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItem_write" "', argument " "1"" of type '" "XdmfItem const *""'"); + } + arg1 = reinterpret_cast< XdmfItem * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfItem_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfItem_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfItem const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfItem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfVisitor_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfVisitor_New")) SWIG_fail; + result = XdmfVisitor::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfVisitor >(static_cast< const boost::shared_ptr< XdmfVisitor >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfArray *arg2 = (XdmfArray *) (XdmfArray *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfArray const *const""'"); + } + arg2 = reinterpret_cast< XdmfArray * >(argp2); + (arg1)->visit((XdmfArray const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfAttribute *arg2 = (XdmfAttribute *) (XdmfAttribute *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfAttribute const *const""'"); + } + arg2 = reinterpret_cast< XdmfAttribute * >(argp2); + (arg1)->visit((XdmfAttribute const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfDomain *arg2 = (XdmfDomain *) (XdmfDomain *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfDomain const *const""'"); + } + arg2 = reinterpret_cast< XdmfDomain * >(argp2); + (arg1)->visit((XdmfDomain const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfGeometry *arg2 = (XdmfGeometry *) (XdmfGeometry *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfGeometry const *const""'"); + } + arg2 = reinterpret_cast< XdmfGeometry * >(argp2); + (arg1)->visit((XdmfGeometry const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfGrid *arg2 = (XdmfGrid *) (XdmfGrid *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfGrid const *const""'"); + } + arg2 = reinterpret_cast< XdmfGrid * >(argp2); + (arg1)->visit((XdmfGrid const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + XdmfTopology *arg2 = (XdmfTopology *) (XdmfTopology *)0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_visit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_visit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfVisitor_visit" "', argument " "2"" of type '" "XdmfTopology const *const""'"); + } + arg2 = reinterpret_cast< XdmfTopology * >(argp2); + (arg1)->visit((XdmfTopology const *)arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_visit(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfAttribute, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfDomain, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_2(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfGeometry, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_3(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_4(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfVisitor, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_XdmfTopology, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfVisitor_visit__SWIG_5(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfVisitor_visit'.\n" + " Possible C/C++ prototypes are:\n" + " visit(XdmfVisitor *,XdmfArray const *const)\n" + " visit(XdmfVisitor *,XdmfAttribute const *const)\n" + " visit(XdmfVisitor *,XdmfDomain const *const)\n" + " visit(XdmfVisitor *,XdmfGeometry const *const)\n" + " visit(XdmfVisitor *,XdmfGrid const *const)\n" + " visit(XdmfVisitor *,XdmfTopology const *const)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitor_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_printSelf" "', argument " "1"" of type '" "XdmfVisitor const *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + result = ((XdmfVisitor const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_getLightDataLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitor_getLightDataLimit",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_getLightDataLimit" "', argument " "1"" of type '" "XdmfVisitor const *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + result = (int)((XdmfVisitor const *)arg1)->getLightDataLimit(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitor_setLightDataLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfVisitor_setLightDataLimit",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_setLightDataLimit" "', argument " "1"" of type '" "XdmfVisitor *""'"); + } + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfVisitor_setLightDataLimit" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setLightDataLimit(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfVisitor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfVisitor, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfDataItem_setArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDataItem *arg1 = (XdmfDataItem *) 0 ; + boost::shared_ptr< XdmfArray > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDataItem_setArray",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItem_setArray" "', argument " "1"" of type '" "XdmfDataItem *""'"); + } + arg1 = reinterpret_cast< XdmfDataItem * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDataItem_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDataItem_setArray" "', argument " "2"" of type '" "boost::shared_ptr< XdmfArray >""'"); + } else { + boost::shared_ptr< XdmfArray > * temp = reinterpret_cast< boost::shared_ptr< XdmfArray > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setArray(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItem_getArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDataItem *arg1 = (XdmfDataItem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItem_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItem_getArray" "', argument " "1"" of type '" "XdmfDataItem *""'"); + } + arg1 = reinterpret_cast< XdmfDataItem * >(argp1); + result = (arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItem_getArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDataItem *arg1 = (XdmfDataItem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfArray const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItem_getArray",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItem_getArray" "', argument " "1"" of type '" "XdmfDataItem const *""'"); + } + arg1 = reinterpret_cast< XdmfDataItem * >(argp1); + result = ((XdmfDataItem const *)arg1)->getArray(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray const >(static_cast< const boost::shared_ptr< XdmfArray const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItem_getArray(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_XdmfDataItem, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfDataItem_getArray__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDataItem, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfDataItem_getArray__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDataItem_getArray'.\n" + " Possible C/C++ prototypes are:\n" + " getArray(XdmfDataItem *)\n" + " getArray(XdmfDataItem const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItem_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDataItem *arg1 = (XdmfDataItem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItem_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItem_printSelf" "', argument " "1"" of type '" "XdmfDataItem const *""'"); + } + arg1 = reinterpret_cast< XdmfDataItem * >(argp1); + result = ((XdmfDataItem const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDataItem_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDataItem *arg1 = (XdmfDataItem *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDataItem_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItem_write" "', argument " "1"" of type '" "XdmfDataItem const *""'"); + } + arg1 = reinterpret_cast< XdmfDataItem * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDataItem_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDataItem_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfDataItem const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfDataItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfDataItem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfAttribute_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfAttribute > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttribute_New")) SWIG_fail; + result = XdmfAttribute::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute >(static_cast< const boost::shared_ptr< XdmfAttribute >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_getName" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttribute_setName",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_setName" "', argument " "1"" of type '" "XdmfAttribute *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttribute_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttribute_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setName((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_getAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_getAttributeType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_getAttributeType" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->getAttributeType(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_setAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + XdmfAttributeType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttribute_setAttributeType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_setAttributeType" "', argument " "1"" of type '" "XdmfAttribute *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttribute_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttribute_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeType * >(argp2); + (arg1)->setAttributeType((XdmfAttributeType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_getAttributeTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_getAttributeTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_getAttributeTypeAsString" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->getAttributeTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_getAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_getAttributeCenter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_getAttributeCenter" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->getAttributeCenter(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_setAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + XdmfAttributeCenter *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttribute_setAttributeCenter",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_setAttributeCenter" "', argument " "1"" of type '" "XdmfAttribute *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttribute_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttribute_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeCenter * >(argp2); + (arg1)->setAttributeCenter((XdmfAttributeCenter const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_getAttributeCenterAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_getAttributeCenterAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_getAttributeCenterAsString" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->getAttributeCenterAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttribute_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_write" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttribute_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttribute_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfAttribute const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttribute_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttribute *arg1 = (XdmfAttribute *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttribute_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttribute, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttribute_printSelf" "', argument " "1"" of type '" "XdmfAttribute const *""'"); + } + arg1 = reinterpret_cast< XdmfAttribute * >(argp1); + result = ((XdmfAttribute const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfAttribute_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfAttribute, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_Grid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeCenter_Grid")) SWIG_fail; + result = XdmfAttributeCenter::Grid(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_Cell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeCenter_Cell")) SWIG_fail; + result = XdmfAttributeCenter::Cell(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_Face(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeCenter_Face")) SWIG_fail; + result = XdmfAttributeCenter::Face(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeCenter_Edge")) SWIG_fail; + result = XdmfAttributeCenter::Edge(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_Node(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeCenter > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeCenter_Node")) SWIG_fail; + result = XdmfAttributeCenter::Node(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeCenter *arg1 = (XdmfAttributeCenter *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributeCenter_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeCenter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeCenter_getName" "', argument " "1"" of type '" "XdmfAttributeCenter const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeCenter * >(argp1); + result = ((XdmfAttributeCenter const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeCenter *arg1 = (XdmfAttributeCenter *) 0 ; + XdmfAttributeCenter *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributeCenter___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeCenter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeCenter___eq__" "', argument " "1"" of type '" "XdmfAttributeCenter const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeCenter * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributeCenter___eq__" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributeCenter___eq__" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeCenter * >(argp2); + result = (bool)((XdmfAttributeCenter const *)arg1)->operator ==((XdmfAttributeCenter const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeCenter___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeCenter *arg1 = (XdmfAttributeCenter *) 0 ; + XdmfAttributeCenter *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributeCenter___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeCenter, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeCenter___ne__" "', argument " "1"" of type '" "XdmfAttributeCenter const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeCenter * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributeCenter___ne__" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributeCenter___ne__" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeCenter * >(argp2); + result = (bool)((XdmfAttributeCenter const *)arg1)->operator !=((XdmfAttributeCenter const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeCenter *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfAttributeCenter *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_XdmfAttributeCenter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfAttributeCenter" "', argument " "1"" of type '" "XdmfAttributeCenter const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XdmfAttributeCenter" "', argument " "1"" of type '" "XdmfAttributeCenter const &""'"); + } + arg1 = reinterpret_cast< XdmfAttributeCenter * >(argp1); + result = (XdmfAttributeCenter *)new XdmfAttributeCenter((XdmfAttributeCenter const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeCenter *arg1 = (XdmfAttributeCenter *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfAttributeCenter",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfAttributeCenter" "', argument " "1"" of type '" "XdmfAttributeCenter *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeCenter * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfAttributeCenter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfAttributeCenter, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_NoAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_NoAttributeType")) SWIG_fail; + result = XdmfAttributeType::NoAttributeType(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_Scalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_Scalar")) SWIG_fail; + result = XdmfAttributeType::Scalar(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_Vector")) SWIG_fail; + result = XdmfAttributeType::Vector(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_Tensor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_Tensor")) SWIG_fail; + result = XdmfAttributeType::Tensor(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_Matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_Matrix")) SWIG_fail; + result = XdmfAttributeType::Matrix(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_Tensor6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_Tensor6")) SWIG_fail; + result = XdmfAttributeType::Tensor6(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_GlobalId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfAttributeType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfAttributeType_GlobalId")) SWIG_fail; + result = XdmfAttributeType::GlobalId(); + resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeType *arg1 = (XdmfAttributeType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributeType_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeType_getName" "', argument " "1"" of type '" "XdmfAttributeType const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeType * >(argp1); + result = ((XdmfAttributeType const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeType *arg1 = (XdmfAttributeType *) 0 ; + XdmfAttributeType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributeType___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeType___eq__" "', argument " "1"" of type '" "XdmfAttributeType const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributeType___eq__" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributeType___eq__" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeType * >(argp2); + result = (bool)((XdmfAttributeType const *)arg1)->operator ==((XdmfAttributeType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfAttributeType___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeType *arg1 = (XdmfAttributeType *) 0 ; + XdmfAttributeType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributeType___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributeType___ne__" "', argument " "1"" of type '" "XdmfAttributeType const *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributeType___ne__" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributeType___ne__" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + } + arg2 = reinterpret_cast< XdmfAttributeType * >(argp2); + result = (bool)((XdmfAttributeType const *)arg1)->operator !=((XdmfAttributeType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeType *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfAttributeType *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_XdmfAttributeType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_XdmfAttributeType, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfAttributeType" "', argument " "1"" of type '" "XdmfAttributeType const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XdmfAttributeType" "', argument " "1"" of type '" "XdmfAttributeType const &""'"); + } + arg1 = reinterpret_cast< XdmfAttributeType * >(argp1); + result = (XdmfAttributeType *)new XdmfAttributeType((XdmfAttributeType const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfAttributeType *arg1 = (XdmfAttributeType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfAttributeType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfAttributeType" "', argument " "1"" of type '" "XdmfAttributeType *""'"); + } + arg1 = reinterpret_cast< XdmfAttributeType * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfAttributeType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfAttributeType, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfArray_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfArray > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfArray_New")) SWIG_fail; + result = XdmfArray::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfArray >(static_cast< const boost::shared_ptr< XdmfArray >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfArray_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getType" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = ((XdmfArray const *)arg1)->getType(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getHDF5Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + hid_t result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getHDF5Type",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getHDF5Type" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = ((XdmfArray const *)arg1)->getHDF5Type(); + resultobj = SWIG_NewPointerObj((new hid_t(static_cast< const hid_t& >(result))), SWIGTYPE_p_hid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getPrecision",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getPrecision" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = (int)((XdmfArray const *)arg1)->getPrecision(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getSize",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getSize" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = (int)((XdmfArray const *)arg1)->getSize(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getValues",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getValues" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = ((XdmfArray const *)arg1)->getValues(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_getValuesPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + void *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_getValuesPointer",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_getValuesPointer" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = (void *)((XdmfArray const *)arg1)->getValuesPointer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfArray_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_printSelf" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + result = ((XdmfArray const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_write" "', argument " "1"" of type '" "XdmfArray const *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfArray const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< char,std::allocator< char > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< char,std::allocator< char > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< char,std::allocator< char > > &""'"); + } + arg2 = reinterpret_cast< std::vector< char,std::allocator< char > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< char >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + short *arg3 = (short *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "short *""'"); + } + arg3 = reinterpret_cast< short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< short,std::allocator< short > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< short,std::allocator< short > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< short,std::allocator< short > > &""'"); + } + arg2 = reinterpret_cast< std::vector< short,std::allocator< short > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< short >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< int,std::allocator< int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); + } + arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< int >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + long *arg3 = (long *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "long *""'"); + } + arg3 = reinterpret_cast< long * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< long,std::allocator< long > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< long,std::allocator< long > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< long,std::allocator< long > > &""'"); + } + arg2 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< long >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_22(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + float *arg3 = (float *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "float *""'"); + } + arg3 = reinterpret_cast< float * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_23(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< float,std::allocator< float > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< float,std::allocator< float > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< float,std::allocator< float > > &""'"); + } + arg2 = reinterpret_cast< std::vector< float,std::allocator< float > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< float >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_24(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_25(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_26(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_27(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< double,std::allocator< double > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > &""'"); + } + arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< double >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_28(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_29(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_30(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned char *arg3 = (unsigned char *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned char *""'"); + } + arg3 = reinterpret_cast< unsigned char * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_31(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< unsigned char,std::allocator< unsigned char > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned char,std::allocator< unsigned char > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned char >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_33(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_34(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned short *arg3 = (unsigned short *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned short *""'"); + } + arg3 = reinterpret_cast< unsigned short * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_35(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< unsigned short,std::allocator< unsigned short > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned short,std::allocator< unsigned short > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned short >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_36(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "XdmfArray_setValues" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_37(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XdmfArray_setValues" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_38(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + int arg2 ; + unsigned int *arg3 = (unsigned int *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:XdmfArray_setValues",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XdmfArray_setValues" "', argument " "3"" of type '" "unsigned int *""'"); + } + arg3 = reinterpret_cast< unsigned int * >(argp3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XdmfArray_setValues" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues__SWIG_39(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfArray *arg1 = (XdmfArray *) 0 ; + std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfArray_setValues",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfArray, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfArray_setValues" "', argument " "1"" of type '" "XdmfArray *""'"); + } + arg1 = reinterpret_cast< XdmfArray * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfArray_setValues" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); + } + arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR setValues< unsigned int >(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfArray_setValues(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[7]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 6); 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_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_7(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_11(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_15(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_19(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_23(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_27(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_31(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_35(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_39(self, args); + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_14(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_26(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_10(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_30(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_18(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_34(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_38(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_22(self, args); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_6(self, args); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_29(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_21(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_9(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_33(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_17(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_25(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_37(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_13(self, args); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_5(self, args); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_24(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_32(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_12(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_20(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_16(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_36(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_28(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_short, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_8(self, args); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfArray, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfArray_setValues__SWIG_4(self, args); + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfArray_setValues'.\n" + " Possible C/C++ prototypes are:\n" + " setValues< char >(XdmfArray *,int,char *,int,int,int)\n" + " setValues< char >(XdmfArray *,int,char *,int,int)\n" + " setValues< char >(XdmfArray *,int,char *,int)\n" + " setValues< char >(XdmfArray *,std::vector< char,std::allocator< char > > &)\n" + " setValues< short >(XdmfArray *,int,short *,int,int,int)\n" + " setValues< short >(XdmfArray *,int,short *,int,int)\n" + " setValues< short >(XdmfArray *,int,short *,int)\n" + " setValues< short >(XdmfArray *,std::vector< short,std::allocator< short > > &)\n" + " setValues< int >(XdmfArray *,int,int *,int,int,int)\n" + " setValues< int >(XdmfArray *,int,int *,int,int)\n" + " setValues< int >(XdmfArray *,int,int *,int)\n" + " setValues< int >(XdmfArray *,std::vector< int,std::allocator< int > > &)\n" + " setValues< long >(XdmfArray *,int,long *,int,int,int)\n" + " setValues< long >(XdmfArray *,int,long *,int,int)\n" + " setValues< long >(XdmfArray *,int,long *,int)\n" + " setValues< long >(XdmfArray *,std::vector< long,std::allocator< long > > &)\n" + " setValues< float >(XdmfArray *,int,float *,int,int,int)\n" + " setValues< float >(XdmfArray *,int,float *,int,int)\n" + " setValues< float >(XdmfArray *,int,float *,int)\n" + " setValues< float >(XdmfArray *,std::vector< float,std::allocator< float > > &)\n" + " setValues< double >(XdmfArray *,int,double *,int,int,int)\n" + " setValues< double >(XdmfArray *,int,double *,int,int)\n" + " setValues< double >(XdmfArray *,int,double *,int)\n" + " setValues< double >(XdmfArray *,std::vector< double,std::allocator< double > > &)\n" + " setValues< unsigned char >(XdmfArray *,int,unsigned char *,int,int,int)\n" + " setValues< unsigned char >(XdmfArray *,int,unsigned char *,int,int)\n" + " setValues< unsigned char >(XdmfArray *,int,unsigned char *,int)\n" + " setValues< unsigned char >(XdmfArray *,std::vector< unsigned char,std::allocator< unsigned char > > &)\n" + " setValues< unsigned short >(XdmfArray *,int,unsigned short *,int,int,int)\n" + " setValues< unsigned short >(XdmfArray *,int,unsigned short *,int,int)\n" + " setValues< unsigned short >(XdmfArray *,int,unsigned short *,int)\n" + " setValues< unsigned short >(XdmfArray *,std::vector< unsigned short,std::allocator< unsigned short > > &)\n" + " setValues< unsigned int >(XdmfArray *,int,unsigned int *,int,int,int)\n" + " setValues< unsigned int >(XdmfArray *,int,unsigned int *,int,int)\n" + " setValues< unsigned int >(XdmfArray *,int,unsigned int *,int)\n" + " setValues< unsigned int >(XdmfArray *,std::vector< unsigned int,std::allocator< unsigned int > > &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *XdmfArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfArray, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfDomain_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfDomain > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfDomain_New")) SWIG_fail; + result = XdmfDomain::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfDomain >(static_cast< const boost::shared_ptr< XdmfDomain >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + boost::shared_ptr< XdmfGrid > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomain_insert",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_insert" "', argument " "1"" of type '" "XdmfDomain *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomain_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomain_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); + } else { + boost::shared_ptr< XdmfGrid > * temp = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->insert(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_getGrid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + boost::shared_ptr< XdmfGrid > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomain_getGrid",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_getGrid" "', argument " "1"" of type '" "XdmfDomain *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomain_getGrid" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (arg1)->getGrid(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid >(static_cast< const boost::shared_ptr< XdmfGrid >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_getGrid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfGrid const > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomain_getGrid",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_getGrid" "', argument " "1"" of type '" "XdmfDomain const *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomain_getGrid" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = ((XdmfDomain const *)arg1)->getGrid(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid const >(static_cast< const boost::shared_ptr< XdmfGrid const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_getGrid(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_XdmfDomain, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfDomain_getGrid__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfDomain, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfDomain_getGrid__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDomain_getGrid'.\n" + " Possible C/C++ prototypes are:\n" + " getGrid(XdmfDomain *,unsigned int)\n" + " getGrid(XdmfDomain const *,unsigned int)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_getNumberOfGrids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomain_getNumberOfGrids",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_getNumberOfGrids" "', argument " "1"" of type '" "XdmfDomain const *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + result = (unsigned int)((XdmfDomain const *)arg1)->getNumberOfGrids(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomain_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_printSelf" "', argument " "1"" of type '" "XdmfDomain const *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + result = ((XdmfDomain const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfDomain_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfDomain *arg1 = (XdmfDomain *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomain_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfDomain, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomain_write" "', argument " "1"" of type '" "XdmfDomain const *""'"); + } + arg1 = reinterpret_cast< XdmfDomain * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomain_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomain_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfDomain const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfDomain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfDomain, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGeometry_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometry_New")) SWIG_fail; + result = XdmfGeometry::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getGeometryType" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = ((XdmfGeometry const *)arg1)->getGeometryType(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_setGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometry_setGeometryType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_setGeometryType" "', argument " "1"" of type '" "XdmfGeometry *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometry_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometry_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + (arg1)->setGeometryType((XdmfGeometryType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getGeometryTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getGeometryTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getGeometryTypeAsString" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = ((XdmfGeometry const *)arg1)->getGeometryTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getDimensions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getDimensions" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = (int)((XdmfGeometry const *)arg1)->getDimensions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_printSelf" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = ((XdmfGeometry const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometry_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_write" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometry_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometry_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfGeometry const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGeometry, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_NoGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_NoGeometryType")) SWIG_fail; + result = XdmfGeometryType::NoGeometryType(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_XYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_XYZ")) SWIG_fail; + result = XdmfGeometryType::XYZ(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_XY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_XY")) SWIG_fail; + result = XdmfGeometryType::XY(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_X_Y_Z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_X_Y_Z")) SWIG_fail; + result = XdmfGeometryType::X_Y_Z(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_X_Y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_X_Y")) SWIG_fail; + result = XdmfGeometryType::X_Y(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_VXVYVZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_VXVYVZ")) SWIG_fail; + result = XdmfGeometryType::VXVYVZ(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_Origin_DXDYDZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_Origin_DXDYDZ")) SWIG_fail; + result = XdmfGeometryType::Origin_DXDYDZ(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_VXVY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_VXVY")) SWIG_fail; + result = XdmfGeometryType::VXVY(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_Origin_DXDY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfGeometryType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometryType_Origin_DXDY")) SWIG_fail; + result = XdmfGeometryType::Origin_DXDY(); + resultobj = SWIG_NewPointerObj((new XdmfGeometryType(static_cast< const XdmfGeometryType& >(result))), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_getDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryType_getDimensions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType_getDimensions" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + result = (int)((XdmfGeometryType const *)arg1)->getDimensions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryType_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType_getName" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + result = ((XdmfGeometryType const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryType___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType___eq__" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryType___eq__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryType___eq__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + result = (bool)((XdmfGeometryType const *)arg1)->operator ==((XdmfGeometryType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryType___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType___ne__" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryType___ne__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryType___ne__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + result = (bool)((XdmfGeometryType const *)arg1)->operator !=((XdmfGeometryType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfGeometryType *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_XdmfGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfGeometryType" "', argument " "1"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XdmfGeometryType" "', argument " "1"" of type '" "XdmfGeometryType const &""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + result = (XdmfGeometryType *)new XdmfGeometryType((XdmfGeometryType const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfGeometryType" "', argument " "1"" of type '" "XdmfGeometryType *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGeometryType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGeometryType, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGrid_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGrid_New")) SWIG_fail; + result = XdmfGrid::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid >(static_cast< const boost::shared_ptr< XdmfGrid >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfGeometry > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getGeometry",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getGeometry" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = (arg1)->getGeometry(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfGeometry const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getGeometry",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getGeometry" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = ((XdmfGrid const *)arg1)->getGeometry(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry const >(static_cast< const boost::shared_ptr< XdmfGeometry const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getGeometry(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGrid_getGeometry__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGrid_getGeometry__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGrid_getGeometry'.\n" + " Possible C/C++ prototypes are:\n" + " getGeometry(XdmfGrid *)\n" + " getGeometry(XdmfGrid const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_setGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + boost::shared_ptr< XdmfGeometry > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_setGeometry",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_setGeometry" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGrid_setGeometry" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGeometry >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGrid_setGeometry" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGeometry >""'"); + } else { + boost::shared_ptr< XdmfGeometry > * temp = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setGeometry(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfTopology > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getTopology",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getTopology" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = (arg1)->getTopology(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology >(static_cast< const boost::shared_ptr< XdmfTopology >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfTopology const > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getTopology",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getTopology" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = ((XdmfGrid const *)arg1)->getTopology(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology const >(static_cast< const boost::shared_ptr< XdmfTopology const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getTopology(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[2]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 1); 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_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGrid_getTopology__SWIG_0(self, args); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_XdmfGrid_getTopology__SWIG_1(self, args); + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGrid_getTopology'.\n" + " Possible C/C++ prototypes are:\n" + " getTopology(XdmfGrid *)\n" + " getTopology(XdmfGrid const *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_setTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + boost::shared_ptr< XdmfTopology > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_setTopology",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_setTopology" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGrid_setTopology" "', argument " "2"" of type '" "boost::shared_ptr< XdmfTopology >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGrid_setTopology" "', argument " "2"" of type '" "boost::shared_ptr< XdmfTopology >""'"); + } else { + boost::shared_ptr< XdmfTopology > * temp = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setTopology(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getName" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = ((XdmfGrid const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_setName",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_setName" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(obj1, &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGrid_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGrid_setName" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setName((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + boost::shared_ptr< XdmfAttribute > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_insert",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_insert" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGrid_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfAttribute >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGrid_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfAttribute >""'"); + } else { + boost::shared_ptr< XdmfAttribute > * temp = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->insert(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + boost::shared_ptr< XdmfAttribute > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_getAttribute",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getAttribute" "', argument " "1"" of type '" "XdmfGrid *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfGrid_getAttribute" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = (arg1)->getAttribute(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute >(static_cast< const boost::shared_ptr< XdmfAttribute >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + unsigned int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + SwigValueWrapper< boost::shared_ptr< XdmfAttribute const > > result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_getAttribute",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getAttribute" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfGrid_getAttribute" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); + result = ((XdmfGrid const *)arg1)->getAttribute(arg2); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute const >(static_cast< const boost::shared_ptr< XdmfAttribute const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_const_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getAttribute(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); 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_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfGrid_getAttribute__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_XdmfGrid, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_XdmfGrid_getAttribute__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfGrid_getAttribute'.\n" + " Possible C/C++ prototypes are:\n" + " getAttribute(XdmfGrid *,unsigned int)\n" + " getAttribute(XdmfGrid const *,unsigned int)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_getNumberOfAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_getNumberOfAttributes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_getNumberOfAttributes" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = (unsigned int)((XdmfGrid const *)arg1)->getNumberOfAttributes(); + resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGrid_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_printSelf" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + result = ((XdmfGrid const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGrid_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGrid *arg1 = (XdmfGrid *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGrid_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGrid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGrid_write" "', argument " "1"" of type '" "XdmfGrid const *""'"); + } + arg1 = reinterpret_cast< XdmfGrid * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGrid_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGrid_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfGrid const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGrid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGrid, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfTopology_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopology_New")) SWIG_fail; + result = XdmfTopology::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfTopology >(static_cast< const boost::shared_ptr< XdmfTopology >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_getTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getTopologyType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getTopologyType" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = ((XdmfTopology const *)arg1)->getTopologyType(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_setTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + XdmfTopologyType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopology_setTopologyType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_setTopologyType" "', argument " "1"" of type '" "XdmfTopology *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfTopologyType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopology_setTopologyType" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopology_setTopologyType" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + arg2 = reinterpret_cast< XdmfTopologyType * >(argp2); + (arg1)->setTopologyType((XdmfTopologyType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_getNumberElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getNumberElements",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getNumberElements" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = (int)((XdmfTopology const *)arg1)->getNumberElements(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_getTopologyTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getTopologyTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getTopologyTypeAsString" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = ((XdmfTopology const *)arg1)->getTopologyTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_getNodesPerElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getNodesPerElement",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getNodesPerElement" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = (int)((XdmfTopology const *)arg1)->getNodesPerElement(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_printSelf" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = ((XdmfTopology const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopology_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + boost::shared_ptr< XdmfVisitor > arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopology_write",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_write" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopology_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopology_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + } else { + boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + ((XdmfTopology const *)arg1)->write(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfTopology_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfTopology, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_NoTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_NoTopologyType")) SWIG_fail; + result = XdmfTopologyType::NoTopologyType(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Polyvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Polyvertex")) SWIG_fail; + result = XdmfTopologyType::Polyvertex(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Polyline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Polyline")) SWIG_fail; + result = XdmfTopologyType::Polyline(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Polygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int temp1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_Polygon",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "XdmfTopologyType_Polygon" "', argument " "1"" of type '" "int""'"); + } + temp1 = static_cast< int >(val1); + arg1 = &temp1; + result = XdmfTopologyType::Polygon((int const &)*arg1); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Triangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Triangle")) SWIG_fail; + result = XdmfTopologyType::Triangle(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Quadrilateral(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Quadrilateral")) SWIG_fail; + result = XdmfTopologyType::Quadrilateral(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Tetrahedron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Tetrahedron")) SWIG_fail; + result = XdmfTopologyType::Tetrahedron(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Pyramid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Pyramid")) SWIG_fail; + result = XdmfTopologyType::Pyramid(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Wedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Wedge")) SWIG_fail; + result = XdmfTopologyType::Wedge(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Hexahedron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Hexahedron")) SWIG_fail; + result = XdmfTopologyType::Hexahedron(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Edge_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Edge_3")) SWIG_fail; + result = XdmfTopologyType::Edge_3(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Triangle_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Triangle_6")) SWIG_fail; + result = XdmfTopologyType::Triangle_6(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Quadrilateral_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Quadrilateral_8")) SWIG_fail; + result = XdmfTopologyType::Quadrilateral_8(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Tetrahedron_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Tetrahedron_10")) SWIG_fail; + result = XdmfTopologyType::Tetrahedron_10(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Pyramid_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Pyramid_13")) SWIG_fail; + result = XdmfTopologyType::Pyramid_13(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Wedge_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Wedge_15")) SWIG_fail; + result = XdmfTopologyType::Wedge_15(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Hexahedron_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Hexahedron_20")) SWIG_fail; + result = XdmfTopologyType::Hexahedron_20(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_Mixed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_Mixed")) SWIG_fail; + result = XdmfTopologyType::Mixed(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_TwoDSMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_TwoDSMesh")) SWIG_fail; + result = XdmfTopologyType::TwoDSMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_TwoDRectMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_TwoDRectMesh")) SWIG_fail; + result = XdmfTopologyType::TwoDRectMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_TwoDCoRectMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_TwoDCoRectMesh")) SWIG_fail; + result = XdmfTopologyType::TwoDCoRectMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_ThreeDSMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_ThreeDSMesh")) SWIG_fail; + result = XdmfTopologyType::ThreeDSMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_ThreeDRectMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_ThreeDRectMesh")) SWIG_fail; + result = XdmfTopologyType::ThreeDRectMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_ThreeDCoRectMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SwigValueWrapper< XdmfTopologyType > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfTopologyType_ThreeDCoRectMesh")) SWIG_fail; + result = XdmfTopologyType::ThreeDCoRectMesh(); + resultobj = SWIG_NewPointerObj((new XdmfTopologyType(static_cast< const XdmfTopologyType& >(result))), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_getNodesPerElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_getNodesPerElement",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_getNodesPerElement" "', argument " "1"" of type '" "XdmfTopologyType const *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + result = (int)((XdmfTopologyType const *)arg1)->getNodesPerElement(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_getName",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_getName" "', argument " "1"" of type '" "XdmfTopologyType const *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + result = ((XdmfTopologyType const *)arg1)->getName(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType_getCellType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfTopologyType::CellType result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_getCellType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_getCellType" "', argument " "1"" of type '" "XdmfTopologyType const *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + result = (XdmfTopologyType::CellType)((XdmfTopologyType const *)arg1)->getCellType(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + XdmfTopologyType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopologyType___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType___eq__" "', argument " "1"" of type '" "XdmfTopologyType const *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfTopologyType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopologyType___eq__" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopologyType___eq__" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + arg2 = reinterpret_cast< XdmfTopologyType * >(argp2); + result = (bool)((XdmfTopologyType const *)arg1)->operator ==((XdmfTopologyType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfTopologyType___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + XdmfTopologyType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfTopologyType___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType___ne__" "', argument " "1"" of type '" "XdmfTopologyType const *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfTopologyType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfTopologyType___ne__" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfTopologyType___ne__" "', argument " "2"" of type '" "XdmfTopologyType const &""'"); + } + arg2 = reinterpret_cast< XdmfTopologyType * >(argp2); + result = (bool)((XdmfTopologyType const *)arg1)->operator !=((XdmfTopologyType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfTopologyType *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_XdmfTopologyType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_XdmfTopologyType, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XdmfTopologyType" "', argument " "1"" of type '" "XdmfTopologyType const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_XdmfTopologyType" "', argument " "1"" of type '" "XdmfTopologyType const &""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + result = (XdmfTopologyType *)new XdmfTopologyType((XdmfTopologyType const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfTopologyType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfTopologyType" "', argument " "1"" of type '" "XdmfTopologyType *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfTopologyType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfTopologyType, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_CharVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_iterator" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_char_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___nonzero__" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = (bool)std_vector_Sl_char_Sg____nonzero__((std::vector< char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___bool__" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = (bool)std_vector_Sl_char_Sg____bool__((std::vector< char > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___len__" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = std_vector_Sl_char_Sg____len__((std::vector< char > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_pop" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + try { + result = (std::vector< char >::value_type)std_vector_Sl_char_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_char(static_cast< char >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + std::vector< char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< char,std::allocator< char > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___getslice__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___getslice__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector___getslice__" "', argument " "3"" of type '" "std::vector< char >::difference_type""'"); + } + arg3 = static_cast< std::vector< char >::difference_type >(val3); + try { + result = (std::vector< char,std::allocator< char > > *)std_vector_Sl_char_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + std::vector< char >::difference_type arg3 ; + std::vector< char,std::allocator< char > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:CharVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___setslice__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___setslice__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector___setslice__" "', argument " "3"" of type '" "std::vector< char >::difference_type""'"); + } + arg3 = static_cast< std::vector< char >::difference_type >(val3); + { + std::vector > *ptr = (std::vector > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CharVector___setslice__" "', argument " "4"" of type '" "std::vector< char,std::allocator< char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CharVector___setslice__" "', argument " "4"" of type '" "std::vector< char,std::allocator< char > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_char_Sg____setslice__(arg1,arg2,arg3,(std::vector< char,std::allocator< char > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + std::vector< char >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___delslice__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___delslice__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector___delslice__" "', argument " "3"" of type '" "std::vector< char >::difference_type""'"); + } + arg3 = static_cast< std::vector< char >::difference_type >(val3); + try { + std_vector_Sl_char_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___delitem__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___delitem__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + try { + std_vector_Sl_char_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< char,std::allocator< char > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___getitem__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< char,std::allocator< char > > *)std_vector_Sl_char_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< char,std::allocator< char > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___setitem__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + { + std::vector > *ptr = (std::vector > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CharVector___setitem__" "', argument " "3"" of type '" "std::vector< char,std::allocator< char > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CharVector___setitem__" "', argument " "3"" of type '" "std::vector< char,std::allocator< char > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_char_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< char,std::allocator< char > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___delitem__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_char_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___delitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_CharVector___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __delitem__(std::vector< char > *,std::vector< char >::difference_type)\n" + " __delitem__(std::vector< char > *,PySliceObject *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< char >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___getitem__" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___getitem__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + try { + { + std::vector< char >::value_type const &_result_ref = std_vector_Sl_char_Sg____getitem____SWIG_1((std::vector< char > const *)arg1,arg2); + result = (std::vector< char >::value_type *) &_result_ref; + } + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_char(static_cast< char >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___getitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_CharVector___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __getitem__(std::vector< char > *,PySliceObject *)\n" + " __getitem__(std::vector< char > const *,std::vector< char >::difference_type)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::difference_type arg2 ; + std::vector< char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< char >::value_type temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector___setitem__" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector___setitem__" "', argument " "2"" of type '" "std::vector< char >::difference_type""'"); + } + arg2 = static_cast< std::vector< char >::difference_type >(val2); + ecode3 = SWIG_AsVal_char(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector___setitem__" "', argument " "3"" of type '" "std::vector< char >::value_type""'"); + } + temp3 = static_cast< std::vector< char >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_char_Sg____setitem____SWIG_1(arg1,arg2,(char const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector___setitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CharVector___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector___setitem____SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __setitem__(std::vector< char > *,PySliceObject *,std::vector< char,std::allocator< char > > const &)\n" + " __setitem__(std::vector< char > *,std::vector< char >::difference_type,std::vector< char >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< char >::value_type temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_append" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_char(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_append" "', argument " "2"" of type '" "std::vector< char >::value_type""'"); + } + temp2 = static_cast< std::vector< char >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_char_Sg__append(arg1,(char const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CharVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_CharVector")) SWIG_fail; + result = (std::vector< char > *)new std::vector< char >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CharVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< char > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_CharVector",&obj0)) SWIG_fail; + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CharVector" "', argument " "1"" of type '" "std::vector< char > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CharVector" "', argument " "1"" of type '" "std::vector< char > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< char > *)new std::vector< char >((std::vector< char > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_empty" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = (bool)((std::vector< char > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_size" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_clear" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_swap" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CharVector_swap" "', argument " "2"" of type '" "std::vector< char > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CharVector_swap" "', argument " "2"" of type '" "std::vector< char > &""'"); + } + arg2 = reinterpret_cast< std::vector< char > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< char > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_get_allocator" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< char >::allocator_type(static_cast< const std::vector< char >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_begin" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_end" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_rbegin" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_rend" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CharVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_CharVector",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CharVector" "', argument " "1"" of type '" "std::vector< char >::size_type""'"); + } + arg1 = static_cast< std::vector< char >::size_type >(val1); + result = (std::vector< char > *)new std::vector< char >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_pop_back" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_resize" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_resize" "', argument " "2"" of type '" "std::vector< char >::size_type""'"); + } + arg2 = static_cast< std::vector< char >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< char >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_erase" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::iterator arg2 ; + std::vector< char >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< char >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_erase" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "3"" of type '" "std::vector< char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_erase" "', argument " "3"" of type '" "std::vector< char >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_erase(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_CharVector_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_CharVector_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector_erase'.\n" + " Possible C/C++ prototypes are:\n" + " erase(std::vector< char > *,std::vector< char >::iterator)\n" + " erase(std::vector< char > *,std::vector< char >::iterator,std::vector< char >::iterator)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CharVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char >::size_type arg1 ; + std::vector< char >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< char >::value_type temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< char > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_CharVector",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CharVector" "', argument " "1"" of type '" "std::vector< char >::size_type""'"); + } + arg1 = static_cast< std::vector< char >::size_type >(val1); + ecode2 = SWIG_AsVal_char(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CharVector" "', argument " "2"" of type '" "std::vector< char >::value_type""'"); + } + temp2 = static_cast< std::vector< char >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< char > *)new std::vector< char >(arg1,(std::vector< char >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CharVector(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_CharVector__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CharVector__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CharVector__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_char(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_CharVector__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_CharVector'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< char >()\n" + " std::vector< char >(std::vector< char > const &)\n" + " std::vector< char >(std::vector< char >::size_type)\n" + " std::vector< char >(std::vector< char >::size_type,std::vector< char >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< char >::value_type temp2 ; + char val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_push_back" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_char(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_push_back" "', argument " "2"" of type '" "std::vector< char >::value_type""'"); + } + temp2 = static_cast< std::vector< char >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< char >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_front" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + { + std::vector< char >::value_type const &_result_ref = ((std::vector< char > const *)arg1)->front(); + result = (std::vector< char >::value_type *) &_result_ref; + } + resultobj = SWIG_From_char(static_cast< char >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_back" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + { + std::vector< char >::value_type const &_result_ref = ((std::vector< char > const *)arg1)->back(); + result = (std::vector< char >::value_type *) &_result_ref; + } + resultobj = SWIG_From_char(static_cast< char >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::size_type arg2 ; + std::vector< char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< char >::value_type temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_assign" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_assign" "', argument " "2"" of type '" "std::vector< char >::size_type""'"); + } + arg2 = static_cast< std::vector< char >::size_type >(val2); + ecode3 = SWIG_AsVal_char(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector_assign" "', argument " "3"" of type '" "std::vector< char >::value_type""'"); + } + temp3 = static_cast< std::vector< char >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::size_type arg2 ; + std::vector< char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< char >::value_type temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_resize" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_resize" "', argument " "2"" of type '" "std::vector< char >::size_type""'"); + } + arg2 = static_cast< std::vector< char >::size_type >(val2); + ecode3 = SWIG_AsVal_char(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector_resize" "', argument " "3"" of type '" "std::vector< char >::value_type""'"); + } + temp3 = static_cast< std::vector< char >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< char >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_resize(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector_resize'.\n" + " Possible C/C++ prototypes are:\n" + " resize(std::vector< char > *,std::vector< char >::size_type)\n" + " resize(std::vector< char > *,std::vector< char >::size_type,std::vector< char >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::iterator arg2 ; + std::vector< char >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< char >::value_type temp3 ; + char val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< char >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:CharVector_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_insert" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_insert" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_insert" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_char(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector_insert" "', argument " "3"" of type '" "std::vector< char >::value_type""'"); + } + temp3 = static_cast< std::vector< char >::value_type >(val3); + arg3 = &temp3; + result = (arg1)->insert(arg2,(std::vector< char >::value_type const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::iterator arg2 ; + std::vector< char >::size_type arg3 ; + std::vector< char >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< char >::value_type temp4 ; + char val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:CharVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_insert" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_insert" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CharVector_insert" "', argument " "2"" of type '" "std::vector< char >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CharVector_insert" "', argument " "3"" of type '" "std::vector< char >::size_type""'"); + } + arg3 = static_cast< std::vector< char >::size_type >(val3); + ecode4 = SWIG_AsVal_char(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CharVector_insert" "', argument " "4"" of type '" "std::vector< char >::value_type""'"); + } + temp4 = static_cast< std::vector< char >::value_type >(val4); + arg4 = &temp4; + (arg1)->insert(arg2,arg3,(std::vector< char >::value_type const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_insert(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 4); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_char(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_char(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CharVector_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'CharVector_insert'.\n" + " Possible C/C++ prototypes are:\n" + " insert(std::vector< char > *,std::vector< char >::iterator,std::vector< char >::value_type const &)\n" + " insert(std::vector< char > *,std::vector< char >::iterator,std::vector< char >::size_type,std::vector< char >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + std::vector< char >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CharVector_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_reserve" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CharVector_reserve" "', argument " "2"" of type '" "std::vector< char >::size_type""'"); + } + arg2 = static_cast< std::vector< char >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CharVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< char >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:CharVector_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CharVector_capacity" "', argument " "1"" of type '" "std::vector< char > const *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + result = ((std::vector< char > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CharVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< char > *arg1 = (std::vector< char > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_CharVector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CharVector" "', argument " "1"" of type '" "std::vector< char > *""'"); + } + arg1 = reinterpret_cast< std::vector< char > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CharVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_ShortVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_iterator" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_short_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___nonzero__" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = (bool)std_vector_Sl_short_Sg____nonzero__((std::vector< short > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___bool__" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = (bool)std_vector_Sl_short_Sg____bool__((std::vector< short > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___len__" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = std_vector_Sl_short_Sg____len__((std::vector< short > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_pop" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + try { + result = (std::vector< short >::value_type)std_vector_Sl_short_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_short(static_cast< short >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + std::vector< short >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< short,std::allocator< short > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___getslice__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___getslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector___getslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'"); + } + arg3 = static_cast< std::vector< short >::difference_type >(val3); + try { + result = (std::vector< short,std::allocator< short > > *)std_vector_Sl_short_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + std::vector< short >::difference_type arg3 ; + std::vector< short,std::allocator< short > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:ShortVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___setslice__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___setslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector___setslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'"); + } + arg3 = static_cast< std::vector< short >::difference_type >(val3); + { + std::vector > *ptr = (std::vector > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ShortVector___setslice__" "', argument " "4"" of type '" "std::vector< short,std::allocator< short > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortVector___setslice__" "', argument " "4"" of type '" "std::vector< short,std::allocator< short > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_short_Sg____setslice__(arg1,arg2,arg3,(std::vector< short,std::allocator< short > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + std::vector< short >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___delslice__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___delslice__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector___delslice__" "', argument " "3"" of type '" "std::vector< short >::difference_type""'"); + } + arg3 = static_cast< std::vector< short >::difference_type >(val3); + try { + std_vector_Sl_short_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___delitem__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___delitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + try { + std_vector_Sl_short_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< short,std::allocator< short > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___getitem__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< short,std::allocator< short > > *)std_vector_Sl_short_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< short,std::allocator< short > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___setitem__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + { + std::vector > *ptr = (std::vector > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShortVector___setitem__" "', argument " "3"" of type '" "std::vector< short,std::allocator< short > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortVector___setitem__" "', argument " "3"" of type '" "std::vector< short,std::allocator< short > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_short_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< short,std::allocator< short > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___delitem__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_short_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___delitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ShortVector___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __delitem__(std::vector< short > *,std::vector< short >::difference_type)\n" + " __delitem__(std::vector< short > *,PySliceObject *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< short >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___getitem__" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___getitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + try { + { + std::vector< short >::value_type const &_result_ref = std_vector_Sl_short_Sg____getitem____SWIG_1((std::vector< short > const *)arg1,arg2); + result = (std::vector< short >::value_type *) &_result_ref; + } + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_short(static_cast< short >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___getitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_ShortVector___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __getitem__(std::vector< short > *,PySliceObject *)\n" + " __getitem__(std::vector< short > const *,std::vector< short >::difference_type)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::difference_type arg2 ; + std::vector< short >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< short >::value_type temp3 ; + short val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector___setitem__" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector___setitem__" "', argument " "2"" of type '" "std::vector< short >::difference_type""'"); + } + arg2 = static_cast< std::vector< short >::difference_type >(val2); + ecode3 = SWIG_AsVal_short(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector___setitem__" "', argument " "3"" of type '" "std::vector< short >::value_type""'"); + } + temp3 = static_cast< std::vector< short >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_short_Sg____setitem____SWIG_1(arg1,arg2,(short const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector___setitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ShortVector___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector___setitem____SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __setitem__(std::vector< short > *,PySliceObject *,std::vector< short,std::allocator< short > > const &)\n" + " __setitem__(std::vector< short > *,std::vector< short >::difference_type,std::vector< short >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< short >::value_type temp2 ; + short val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_append" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_short(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_append" "', argument " "2"" of type '" "std::vector< short >::value_type""'"); + } + temp2 = static_cast< std::vector< short >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_short_Sg__append(arg1,(short const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ShortVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ShortVector")) SWIG_fail; + result = (std::vector< short > *)new std::vector< short >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ShortVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< short > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ShortVector",&obj0)) SWIG_fail; + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ShortVector" "', argument " "1"" of type '" "std::vector< short > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ShortVector" "', argument " "1"" of type '" "std::vector< short > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< short > *)new std::vector< short >((std::vector< short > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_empty" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = (bool)((std::vector< short > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_size" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_clear" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_swap" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShortVector_swap" "', argument " "2"" of type '" "std::vector< short > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShortVector_swap" "', argument " "2"" of type '" "std::vector< short > &""'"); + } + arg2 = reinterpret_cast< std::vector< short > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< short > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_get_allocator" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< short >::allocator_type(static_cast< const std::vector< short >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_begin" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_end" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_rbegin" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_rend" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ShortVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_ShortVector",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShortVector" "', argument " "1"" of type '" "std::vector< short >::size_type""'"); + } + arg1 = static_cast< std::vector< short >::size_type >(val1); + result = (std::vector< short > *)new std::vector< short >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_pop_back" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_resize" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_resize" "', argument " "2"" of type '" "std::vector< short >::size_type""'"); + } + arg2 = static_cast< std::vector< short >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< short >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_erase" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::iterator arg2 ; + std::vector< short >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< short >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_erase" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "3"" of type '" "std::vector< short >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_erase" "', argument " "3"" of type '" "std::vector< short >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_erase(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ShortVector_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_ShortVector_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector_erase'.\n" + " Possible C/C++ prototypes are:\n" + " erase(std::vector< short > *,std::vector< short >::iterator)\n" + " erase(std::vector< short > *,std::vector< short >::iterator,std::vector< short >::iterator)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ShortVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short >::size_type arg1 ; + std::vector< short >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< short >::value_type temp2 ; + short val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< short > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_ShortVector",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShortVector" "', argument " "1"" of type '" "std::vector< short >::size_type""'"); + } + arg1 = static_cast< std::vector< short >::size_type >(val1); + ecode2 = SWIG_AsVal_short(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShortVector" "', argument " "2"" of type '" "std::vector< short >::value_type""'"); + } + temp2 = static_cast< std::vector< short >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< short > *)new std::vector< short >(arg1,(std::vector< short >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ShortVector(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_ShortVector__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ShortVector__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ShortVector__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_short(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ShortVector__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_ShortVector'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< short >()\n" + " std::vector< short >(std::vector< short > const &)\n" + " std::vector< short >(std::vector< short >::size_type)\n" + " std::vector< short >(std::vector< short >::size_type,std::vector< short >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< short >::value_type temp2 ; + short val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_push_back" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_short(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_push_back" "', argument " "2"" of type '" "std::vector< short >::value_type""'"); + } + temp2 = static_cast< std::vector< short >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< short >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_front" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + { + std::vector< short >::value_type const &_result_ref = ((std::vector< short > const *)arg1)->front(); + result = (std::vector< short >::value_type *) &_result_ref; + } + resultobj = SWIG_From_short(static_cast< short >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_back" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + { + std::vector< short >::value_type const &_result_ref = ((std::vector< short > const *)arg1)->back(); + result = (std::vector< short >::value_type *) &_result_ref; + } + resultobj = SWIG_From_short(static_cast< short >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::size_type arg2 ; + std::vector< short >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< short >::value_type temp3 ; + short val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_assign" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_assign" "', argument " "2"" of type '" "std::vector< short >::size_type""'"); + } + arg2 = static_cast< std::vector< short >::size_type >(val2); + ecode3 = SWIG_AsVal_short(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector_assign" "', argument " "3"" of type '" "std::vector< short >::value_type""'"); + } + temp3 = static_cast< std::vector< short >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< short >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::size_type arg2 ; + std::vector< short >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< short >::value_type temp3 ; + short val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_resize" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_resize" "', argument " "2"" of type '" "std::vector< short >::size_type""'"); + } + arg2 = static_cast< std::vector< short >::size_type >(val2); + ecode3 = SWIG_AsVal_short(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector_resize" "', argument " "3"" of type '" "std::vector< short >::value_type""'"); + } + temp3 = static_cast< std::vector< short >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< short >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_resize(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector_resize'.\n" + " Possible C/C++ prototypes are:\n" + " resize(std::vector< short > *,std::vector< short >::size_type)\n" + " resize(std::vector< short > *,std::vector< short >::size_type,std::vector< short >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::iterator arg2 ; + std::vector< short >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< short >::value_type temp3 ; + short val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< short >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:ShortVector_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_insert" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_short(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector_insert" "', argument " "3"" of type '" "std::vector< short >::value_type""'"); + } + temp3 = static_cast< std::vector< short >::value_type >(val3); + arg3 = &temp3; + result = (arg1)->insert(arg2,(std::vector< short >::value_type const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< short >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::iterator arg2 ; + std::vector< short >::size_type arg3 ; + std::vector< short >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< short >::value_type temp4 ; + short val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:ShortVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_insert" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ShortVector_insert" "', argument " "2"" of type '" "std::vector< short >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShortVector_insert" "', argument " "3"" of type '" "std::vector< short >::size_type""'"); + } + arg3 = static_cast< std::vector< short >::size_type >(val3); + ecode4 = SWIG_AsVal_short(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ShortVector_insert" "', argument " "4"" of type '" "std::vector< short >::value_type""'"); + } + temp4 = static_cast< std::vector< short >::value_type >(val4); + arg4 = &temp4; + (arg1)->insert(arg2,arg3,(std::vector< short >::value_type const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_insert(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 4); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_short(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ShortVector_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'ShortVector_insert'.\n" + " Possible C/C++ prototypes are:\n" + " insert(std::vector< short > *,std::vector< short >::iterator,std::vector< short >::value_type const &)\n" + " insert(std::vector< short > *,std::vector< short >::iterator,std::vector< short >::size_type,std::vector< short >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + std::vector< short >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ShortVector_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_reserve" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShortVector_reserve" "', argument " "2"" of type '" "std::vector< short >::size_type""'"); + } + arg2 = static_cast< std::vector< short >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ShortVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< short >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:ShortVector_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShortVector_capacity" "', argument " "1"" of type '" "std::vector< short > const *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + result = ((std::vector< short > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ShortVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< short > *arg1 = (std::vector< short > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ShortVector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShortVector" "', argument " "1"" of type '" "std::vector< short > *""'"); + } + arg1 = reinterpret_cast< std::vector< short > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ShortVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_IntVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + try { + result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int,std::allocator< int > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + try { + result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + std::vector< int,std::allocator< int > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + { + std::vector > *ptr = (std::vector > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'"); + } + arg3 = static_cast< std::vector< int >::difference_type >(val3); + try { + std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + try { + std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int,std::allocator< int > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< int,std::allocator< int > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + { + std::vector > *ptr = (std::vector > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___delitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_IntVector___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __delitem__(std::vector< int > *,std::vector< int >::difference_type)\n" + " __delitem__(std::vector< int > *,PySliceObject *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + try { + { + std::vector< int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2); + result = (std::vector< int >::value_type *) &_result_ref; + } + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___getitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_IntVector___getitem____SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __getitem__(std::vector< int > *,PySliceObject *)\n" + " __getitem__(std::vector< int > const *,std::vector< int >::difference_type)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::difference_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'"); + } + arg2 = static_cast< std::vector< int >::difference_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2,(int const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector___setitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntVector___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector___setitem____SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __setitem__(std::vector< int > *,PySliceObject *,std::vector< int,std::allocator< int > > const &)\n" + " __setitem__(std::vector< int > *,std::vector< int >::difference_type,std::vector< int >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_IntVector")) SWIG_fail; + result = (std::vector< int > *)new std::vector< int >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail; + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; +fail: + if (SWIG_IsNewObj(res1)) delete arg1; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = (bool)((std::vector< int > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); + } + arg2 = reinterpret_cast< std::vector< int > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + SwigValueWrapper< std::allocator< int > > result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::const_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::const_reverse_iterator result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_IntVector",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); + } + arg1 = static_cast< std::vector< int >::size_type >(val1); + result = (std::vector< int > *)new std::vector< int >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + (arg1)->resize(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::iterator arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_erase(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_IntVector_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_IntVector_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_erase'.\n" + " Possible C/C++ prototypes are:\n" + " erase(std::vector< int > *,std::vector< int >::iterator)\n" + " erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int >::size_type arg1 ; + std::vector< int >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< int > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:new_IntVector",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'"); + } + arg1 = static_cast< std::vector< int >::size_type >(val1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntVector(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_new_IntVector__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_IntVector__SWIG_2(self, args); + } + } + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_IntVector__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_IntVector__SWIG_3(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_IntVector'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< int >()\n" + " std::vector< int >(std::vector< int > const &)\n" + " std::vector< int >(std::vector< int >::size_type)\n" + " std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< int >::value_type temp2 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'"); + } + temp2 = static_cast< std::vector< int >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< int >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->front(); + result = (std::vector< int >::value_type *) &_result_ref; + } + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::value_type *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + { + std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->back(); + result = (std::vector< int >::value_type *) &_result_ref; + } + resultobj = SWIG_From_int(static_cast< int >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_resize(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector_resize__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_resize'.\n" + " Possible C/C++ prototypes are:\n" + " resize(std::vector< int > *,std::vector< int >::size_type)\n" + " resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< int >::value_type temp3 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< int >::iterator result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:IntVector_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'"); + } + temp3 = static_cast< std::vector< int >::value_type >(val3); + arg3 = &temp3; + result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::iterator arg2 ; + std::vector< int >::size_type arg3 ; + std::vector< int >::value_type *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< int >::value_type temp4 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:IntVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'"); + } + arg3 = static_cast< std::vector< int >::size_type >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'"); + } + temp4 = static_cast< std::vector< int >::value_type >(val4); + arg4 = &temp4; + (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_insert(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 4); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_IntVector_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'IntVector_insert'.\n" + " Possible C/C++ prototypes are:\n" + " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n" + " insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + std::vector< int >::size_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:IntVector_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'"); + } + arg2 = static_cast< std::vector< int >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< int >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:IntVector_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + result = ((std::vector< int > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IntVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< int > *arg1 = (std::vector< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_IntVector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'"); + } + arg1 = reinterpret_cast< std::vector< int > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_LongVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + swig::SwigPyIterator *result = 0 ; + + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_iterator" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_long_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - size_t val2 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:LongVector___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___nonzero__" "', argument " "1"" of type '" "std::vector< long > const *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = (bool)std_vector_Sl_long_Sg____nonzero__((std::vector< long > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:LongVector___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___bool__" "', argument " "1"" of type '" "std::vector< long > const *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = (bool)std_vector_Sl_long_Sg____bool__((std::vector< long > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< long >::size_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:LongVector___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___len__" "', argument " "1"" of type '" "std::vector< long > const *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = std_vector_Sl_long_Sg____len__((std::vector< long > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< long >::value_type result; + + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_pop" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + try { + result = (std::vector< long >::value_type)std_vector_Sl_long_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_long(static_cast< long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; + std::vector< long >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; + PyObject * obj2 = 0 ; + std::vector< long,std::allocator< long > > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___getslice__" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___getslice__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); } - arg2 = static_cast< size_t >(val2); + arg2 = static_cast< std::vector< long >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector___getslice__" "', argument " "3"" of type '" "std::vector< long >::difference_type""'"); + } + arg3 = static_cast< std::vector< long >::difference_type >(val3); try { - result = (swig::SwigPyIterator *)(arg1)->decr(arg2); + result = (std::vector< long,std::allocator< long > > *)std_vector_Sl_long_Sg____getslice__(arg1,arg2,arg3); } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; + std::vector< long >::difference_type arg3 ; + std::vector< long,std::allocator< long > > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:LongVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___setslice__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___setslice__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); + } + arg2 = static_cast< std::vector< long >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector___setslice__" "', argument " "3"" of type '" "std::vector< long >::difference_type""'"); + } + arg3 = static_cast< std::vector< long >::difference_type >(val3); + { + std::vector > *ptr = (std::vector > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LongVector___setslice__" "', argument " "4"" of type '" "std::vector< long,std::allocator< long > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LongVector___setslice__" "', argument " "4"" of type '" "std::vector< long,std::allocator< long > > const &""'"); + } + arg4 = ptr; + } + try { + std_vector_Sl_long_Sg____setslice__(arg1,arg2,arg3,(std::vector< long,std::allocator< long > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; + return resultobj; +fail: + if (SWIG_IsNewObj(res4)) delete arg4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; + std::vector< long >::difference_type arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___delslice__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___delslice__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); + } + arg2 = static_cast< std::vector< long >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector___delslice__" "', argument " "3"" of type '" "std::vector< long >::difference_type""'"); + } + arg3 = static_cast< std::vector< long >::difference_type >(val3); + try { + std_vector_Sl_long_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___delitem__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___delitem__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); + } + arg2 = static_cast< std::vector< long >::difference_type >(val2); + try { + std_vector_Sl_long_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + std::vector< long,std::allocator< long > > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___getitem__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< long,std::allocator< long > > *)std_vector_Sl_long_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< long,std::allocator< long > > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res3 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___setitem__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + { + std::vector > *ptr = (std::vector > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LongVector___setitem__" "', argument " "3"" of type '" "std::vector< long,std::allocator< long > > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LongVector___setitem__" "', argument " "3"" of type '" "std::vector< long,std::allocator< long > > const &""'"); + } + arg3 = ptr; + } + try { + std_vector_Sl_long_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< long,std::allocator< long > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; + return resultobj; +fail: + if (SWIG_IsNewObj(res3)) delete arg3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___delitem__" "', argument " "1"" of type '" "std::vector< long > *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_long_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector___delitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_LongVector___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector___delitem____SWIG_0(self, args); + } } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - return resultobj; fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __delitem__(std::vector< long > *,std::vector< long >::difference_type)\n" + " __delitem__(std::vector< long > *,PySliceObject *)\n"); return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; + PyObject * obj1 = 0 ; + std::vector< long >::value_type *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___getitem__" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___getitem__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); + } + arg2 = static_cast< std::vector< long >::difference_type >(val2); try { - result = (swig::SwigPyIterator *)(arg1)->decr(); - } - catch(swig::stop_iteration &_e) { { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; + std::vector< long >::value_type const &_result_ref = std_vector_Sl_long_Sg____getitem____SWIG_1((std::vector< long > const *)arg1,arg2); + result = (std::vector< long >::value_type *) &_result_ref; } } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; @@ -3648,646 +24610,499 @@ SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) { for (ii = 0; (ii < argc) && (ii < 2); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 1) { + if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SwigPyIterator_decr__SWIG_1(self, args); + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_LongVector___getitem____SWIG_0(self, args); + } } } if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); + int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_size_t(argv[1], NULL); + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SwigPyIterator_decr__SWIG_0(self, args); + return _wrap_LongVector___getitem____SWIG_1(self, args); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'SwigPyIterator_decr'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector___getitem__'.\n" " Possible C/C++ prototypes are:\n" - " decr(swig::SwigPyIterator *,size_t)\n" - " decr(swig::SwigPyIterator *)\n"); + " __getitem__(std::vector< long > *,PySliceObject *)\n" + " __getitem__(std::vector< long > const *,std::vector< long >::difference_type)\n"); return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::difference_type arg2 ; + std::vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< long >::value_type temp3 ; + long val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - ptrdiff_t result; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector___setitem__" "', argument " "1"" of type '" "std::vector< long > *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector___setitem__" "', argument " "2"" of type '" "std::vector< long >::difference_type""'"); + } + arg2 = static_cast< std::vector< long >::difference_type >(val2); + ecode3 = SWIG_AsVal_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector___setitem__" "', argument " "3"" of type '" "std::vector< long >::value_type""'"); + } + temp3 = static_cast< std::vector< long >::value_type >(val3); + arg3 = &temp3; try { - result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2); + std_vector_Sl_long_Sg____setitem____SWIG_1(arg1,arg2,(long const &)*arg3); } - catch(std::invalid_argument &_e) { - SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); } - resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; +SWIGINTERN PyObject *_wrap_LongVector___setitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - try { - result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2); + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_LongVector___setitem____SWIG_0(self, args); + } + } + } } - catch(std::invalid_argument &_e) { - SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail; + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector___setitem____SWIG_1(self, args); + } + } + } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __setitem__(std::vector< long > *,PySliceObject *,std::vector< long,std::allocator< long > > const &)\n" + " __setitem__(std::vector< long > *,std::vector< long >::difference_type,std::vector< long >::value_type const &)\n"); return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + std::vector< long >::value_type temp2 ; + long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - swig::SwigPyIterator *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_append" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_append" "', argument " "2"" of type '" "std::vector< long >::value_type""'"); + } + temp2 = static_cast< std::vector< long >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_long_Sg__append(arg1,(long const &)*arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_LongVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->next(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } + std::vector< long > *result = 0 ; - resultobj = result; + if (!PyArg_ParseTuple(args,(char *)":new_LongVector")) SWIG_fail; + result = (std::vector< long > *)new std::vector< long >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_LongVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + std::vector< long > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; - PyObject *result = 0 ; + std::vector< long > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->__next__(); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:new_LongVector",&obj0)) SWIG_fail; + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LongVector" "', argument " "1"" of type '" "std::vector< long > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LongVector" "', argument " "1"" of type '" "std::vector< long > const &""'"); } + arg1 = ptr; } - - resultobj = result; + result = (std::vector< long > *)new std::vector< long >((std::vector< long > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; return resultobj; fail: + if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - PyObject *result = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - try { - result = (PyObject *)(arg1)->previous(); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_empty" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } - - resultobj = result; + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = (bool)((std::vector< long > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)(arg1)->advance(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } - } + PyObject * obj0 = 0 ; + std::vector< long >::size_type result; - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_size" "', argument " "1"" of type '" "std::vector< long > const *""'"); + } + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_clear" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + (arg1)->clear(); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_swap",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_swap" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LongVector_swap" "', argument " "2"" of type '" "std::vector< long > &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LongVector_swap" "', argument " "2"" of type '" "std::vector< long > &""'"); } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_bool(static_cast< bool >(result)); + arg2 = reinterpret_cast< std::vector< long > * >(argp2); + (arg1)->swap(*arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; + SwigValueWrapper< std::allocator< long > > result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_get_allocator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_get_allocator" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->get_allocator(); + resultobj = SWIG_NewPointerObj((new std::vector< long >::allocator_type(static_cast< const std::vector< long >::allocator_type& >(result))), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t__allocator_type, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; + std::vector< long >::const_iterator result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_begin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_begin" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->begin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; + std::vector< long >::const_iterator result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_end",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_end" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->end(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::const_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - ptrdiff_t arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - ptrdiff_t val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - swig::SwigPyIterator *result = 0 ; + std::vector< long >::const_reverse_iterator result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_rbegin",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'"); - } - arg2 = static_cast< ptrdiff_t >(val2); - try { - result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2); - } - catch(swig::stop_iteration &_e) { - { - (void)_e; - SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void()); - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_rbegin" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->rbegin(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ; - swig::SwigPyIterator *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - ptrdiff_t result; + std::vector< long >::const_reverse_iterator result; - if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_rend",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); - } - arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_rend" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2); - result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2); - resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->rend(); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::const_reverse_iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) { - int argc; - PyObject *argv[3]; - int ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = (int)PyObject_Length(args); - for (ii = 0; (ii < argc) && (ii < 2); 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_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SwigPyIterator___sub____SWIG_1(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SwigPyIterator___sub____SWIG_0(self, args); - } - } - } +SWIGINTERN PyObject *_wrap_new_LongVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< long >::size_type arg1 ; + size_t val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + std::vector< long > *result = 0 ; + if (!PyArg_ParseTuple(args,(char *)"O:new_LongVector",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LongVector" "', argument " "1"" of type '" "std::vector< long >::size_type""'"); + } + arg1 = static_cast< std::vector< long >::size_type >(val1); + result = (std::vector< long > *)new std::vector< long >(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + return NULL; } -SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_XdmfAttributePtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - XdmfAttribute *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_pop_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_pop_back" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (XdmfAttribute *)((boost::shared_ptr< XdmfAttribute > const *)arg1)->operator ->(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfAttribute, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_XdmfAttributePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_XdmfAttributePtr")) SWIG_fail; - result = (boost::shared_ptr< XdmfAttribute > *)new boost::shared_ptr< XdmfAttribute >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + (arg1)->pop_back(); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_XdmfAttributePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfAttributePtr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_resize",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfAttributePtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_resize" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - delete arg1; + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_resize" "', argument " "2"" of type '" "std::vector< long >::size_type""'"); + } + arg2 = static_cast< std::vector< long >::size_type >(val2); + (arg1)->resize(arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4295,272 +25110,556 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::iterator arg2 ; void *argp1 = 0 ; int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; PyObject * obj0 = 0 ; - boost::shared_ptr< XdmfAttribute > result; + PyObject * obj1 = 0 ; + std::vector< long >::iterator result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_New",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_erase",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_erase" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfAttribute >(static_cast< const boost::shared_ptr< XdmfAttribute >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } + } + result = (arg1)->erase(arg2); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::iterator arg2 ; + std::vector< long >::iterator arg3 ; void *argp1 = 0 ; int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + swig::SwigPyIterator *iter3 = 0 ; + int res3 ; PyObject * obj0 = 0 ; - std::string result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< long >::iterator result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector_erase",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_erase" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->getName(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } + } + res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res3) || !iter3) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "3"" of type '" "std::vector< long >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter3); + if (iter_t) { + arg3 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_erase" "', argument " "3"" of type '" "std::vector< long >::iterator""'"); + } + } + result = (arg1)->erase(arg2,arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_erase(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_LongVector_erase__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + return _wrap_LongVector_erase__SWIG_1(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector_erase'.\n" + " Possible C/C++ prototypes are:\n" + " erase(std::vector< long > *,std::vector< long >::iterator)\n" + " erase(std::vector< long > *,std::vector< long >::iterator,std::vector< long >::iterator)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_LongVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; - std::string *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 = SWIG_OLDOBJ ; + std::vector< long >::size_type arg1 ; + std::vector< long >::value_type *arg2 = 0 ; + size_t val1 ; + int ecode1 = 0 ; + std::vector< long >::value_type temp2 ; + long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + std::vector< long > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setName",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setName" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + if (!PyArg_ParseTuple(args,(char *)"OO:new_LongVector",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LongVector" "', argument " "1"" of type '" "std::vector< long >::size_type""'"); + } + arg1 = static_cast< std::vector< long >::size_type >(val1); + ecode2 = SWIG_AsVal_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LongVector" "', argument " "2"" of type '" "std::vector< long >::value_type""'"); + } + temp2 = static_cast< std::vector< long >::value_type >(val2); + arg2 = &temp2; + result = (std::vector< long > *)new std::vector< long >(arg1,(std::vector< long >::value_type const &)*arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_LongVector(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - { - std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + if (argc == 0) { + return _wrap_new_LongVector__SWIG_0(self, args); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); } - if (!ptr) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setName" "', argument " "2"" of type '" "std::string const &""'"); + if (_v) { + return _wrap_new_LongVector__SWIG_2(self, args); } - arg2 = ptr; } - (*arg1)->setName((std::string const &)*arg2); - resultobj = SWIG_Py_Void(); - if (SWIG_IsNewObj(res2)) delete arg2; - return resultobj; + if (argc == 1) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_LongVector__SWIG_1(self, args); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_size_t(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_LongVector__SWIG_3(self, args); + } + } + } + fail: - if (SWIG_IsNewObj(res2)) delete arg2; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_LongVector'.\n" + " Possible C/C++ prototypes are:\n" + " std::vector< long >()\n" + " std::vector< long >(std::vector< long > const &)\n" + " std::vector< long >(std::vector< long >::size_type)\n" + " std::vector< long >(std::vector< long >::size_type,std::vector< long >::value_type const &)\n"); return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::value_type *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + std::vector< long >::value_type temp2 ; + long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - SwigValueWrapper< XdmfAttributeType > result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_push_back",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_push_back" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->getAttributeType(); - resultobj = SWIG_NewPointerObj((new XdmfAttributeType(static_cast< const XdmfAttributeType& >(result))), SWIGTYPE_p_XdmfAttributeType, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_push_back" "', argument " "2"" of type '" "std::vector< long >::value_type""'"); + } + temp2 = static_cast< std::vector< long >::value_type >(val2); + arg2 = &temp2; + (arg1)->push_back((std::vector< long >::value_type const &)*arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setAttributeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; - XdmfAttributeType *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + std::vector< long >::value_type *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setAttributeType",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_front",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); - } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeType, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_front" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setAttributeType" "', argument " "2"" of type '" "XdmfAttributeType const &""'"); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + { + std::vector< long >::value_type const &_result_ref = ((std::vector< long > const *)arg1)->front(); + result = (std::vector< long >::value_type *) &_result_ref; } - arg2 = reinterpret_cast< XdmfAttributeType * >(argp2); - (*arg1)->setAttributeType((XdmfAttributeType const &)*arg2); - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - std::string result; + std::vector< long >::value_type *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeTypeAsString",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_back",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeTypeAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_back" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->getAttributeTypeAsString(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + { + std::vector< long >::value_type const &_result_ref = ((std::vector< long > const *)arg1)->back(); + result = (std::vector< long >::value_type *) &_result_ref; + } + resultobj = SWIG_From_long(static_cast< long >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::size_type arg2 ; + std::vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< long >::value_type temp3 ; + long val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; - SwigValueWrapper< XdmfAttributeCenter > result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeCenter",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector_assign",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeCenter" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_assign" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->getAttributeCenter(); - resultobj = SWIG_NewPointerObj((new XdmfAttributeCenter(static_cast< const XdmfAttributeCenter& >(result))), SWIGTYPE_p_XdmfAttributeCenter, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_assign" "', argument " "2"" of type '" "std::vector< long >::size_type""'"); + } + arg2 = static_cast< std::vector< long >::size_type >(val2); + ecode3 = SWIG_AsVal_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector_assign" "', argument " "3"" of type '" "std::vector< long >::value_type""'"); + } + temp3 = static_cast< std::vector< long >::value_type >(val3); + arg3 = &temp3; + (arg1)->assign(arg2,(std::vector< long >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setAttributeCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; - XdmfAttributeCenter *arg2 = 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::size_type arg2 ; + std::vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + size_t val2 ; + int ecode2 = 0 ; + std::vector< long >::value_type temp3 ; + long val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setAttributeCenter",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector_resize",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_resize" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfAttributeCenter, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_resize" "', argument " "2"" of type '" "std::vector< long >::size_type""'"); + } + arg2 = static_cast< std::vector< long >::size_type >(val2); + ecode3 = SWIG_AsVal_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector_resize" "', argument " "3"" of type '" "std::vector< long >::value_type""'"); + } + temp3 = static_cast< std::vector< long >::value_type >(val3); + arg3 = &temp3; + (arg1)->resize(arg2,(std::vector< long >::value_type const &)*arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector_resize(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_setAttributeCenter" "', argument " "2"" of type '" "XdmfAttributeCenter const &""'"); + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector_resize__SWIG_0(self, args); + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector_resize__SWIG_1(self, args); + } + } + } } - arg2 = reinterpret_cast< XdmfAttributeCenter * >(argp2); - (*arg1)->setAttributeCenter((XdmfAttributeCenter const &)*arg2); - resultobj = SWIG_Py_Void(); - return resultobj; + fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector_resize'.\n" + " Possible C/C++ prototypes are:\n" + " resize(std::vector< long > *,std::vector< long >::size_type)\n" + " resize(std::vector< long > *,std::vector< long >::size_type,std::vector< long >::value_type const &)\n"); return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getAttributeCenterAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::iterator arg2 ; + std::vector< long >::value_type *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + std::vector< long >::value_type temp3 ; + long val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; - std::string result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< long >::iterator result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getAttributeCenterAsString",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:LongVector_insert",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getAttributeCenterAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_insert" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->getAttributeCenterAsString(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_insert" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); + } else { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_insert" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } + } + ecode3 = SWIG_AsVal_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector_insert" "', argument " "3"" of type '" "std::vector< long >::value_type""'"); + } + temp3 = static_cast< std::vector< long >::value_type >(val3); + arg3 = &temp3; + result = (arg1)->insert(arg2,(std::vector< long >::value_type const &)*arg3); + resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< long >::iterator & >(result)), + swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; - boost::shared_ptr< XdmfVisitor > arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::iterator arg2 ; + std::vector< long >::size_type arg3 ; + std::vector< long >::value_type *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; + swig::SwigPyIterator *iter2 = 0 ; + int res2 ; + size_t val3 ; + int ecode3 = 0 ; + std::vector< long >::value_type temp4 ; + long val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_write",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:LongVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_insert" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfAttributePtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfAttributePtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0); + if (!SWIG_IsOK(res2) || !iter2) { + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_insert" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); + } else { + swig::SwigPyIterator_T::iterator > *iter_t = dynamic_cast::iterator > *>(iter2); + if (iter_t) { + arg2 = iter_t->get_current(); } else { - boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; + SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LongVector_insert" "', argument " "2"" of type '" "std::vector< long >::iterator""'"); } } - (*arg1)->write(arg2); + ecode3 = SWIG_AsVal_size_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LongVector_insert" "', argument " "3"" of type '" "std::vector< long >::size_type""'"); + } + arg3 = static_cast< std::vector< long >::size_type >(val3); + ecode4 = SWIG_AsVal_long(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LongVector_insert" "', argument " "4"" of type '" "std::vector< long >::value_type""'"); + } + temp4 = static_cast< std::vector< long >::value_type >(val4); + arg4 = &temp4; + (arg1)->insert(arg2,arg3,(std::vector< long >::value_type const &)*arg4); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4568,303 +25667,452 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_insert(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[5]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 4); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector_insert__SWIG_0(self, args); + } + } + } + } + if (argc == 4) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + swig::SwigPyIterator *iter = 0; + int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0); + _v = (SWIG_IsOK(res) && iter && (dynamic_cast::iterator > *>(iter) != 0)); + if (_v) { + { + int res = SWIG_AsVal_size_t(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LongVector_insert__SWIG_1(self, args); + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'LongVector_insert'.\n" + " Possible C/C++ prototypes are:\n" + " insert(std::vector< long > *,std::vector< long >::iterator,std::vector< long >::value_type const &)\n" + " insert(std::vector< long > *,std::vector< long >::iterator,std::vector< long >::size_type,std::vector< long >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LongVector_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; + std::vector< long >::size_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; + size_t val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; - std::string result; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_printSelf",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:LongVector_reserve",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_reserve" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (*arg1)->printSelf(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + ecode2 = SWIG_AsVal_size_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LongVector_reserve" "', argument " "2"" of type '" "std::vector< long >::size_type""'"); + } + arg2 = static_cast< std::vector< long >::size_type >(val2); + (arg1)->reserve(arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_setNumberValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LongVector_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; - int arg2 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + std::vector< long >::size_type result; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfAttributePtr_setNumberValues",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:LongVector_capacity",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_setNumberValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LongVector_capacity" "', argument " "1"" of type '" "std::vector< long > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - ecode2 = SWIG_AsVal_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfAttributePtr_setNumberValues" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - (*arg1)->setNumberValues(arg2); - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + result = ((std::vector< long > const *)arg1)->capacity(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfAttributePtr_getNumberValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_LongVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfAttribute > *arg1 = (boost::shared_ptr< XdmfAttribute > *) 0 ; + std::vector< long > *arg1 = (std::vector< long > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfAttributePtr_getNumberValues",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:delete_LongVector",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfAttributePtr_getNumberValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfAttribute > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LongVector" "', argument " "1"" of type '" "std::vector< long > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfAttribute > * >(argp1); - result = (int)(*arg1)->getNumberValues(); - resultobj = SWIG_From_int(static_cast< int >(result)); + arg1 = reinterpret_cast< std::vector< long > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *XdmfAttributePtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *LongVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfAttribute_t, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_XdmfDataItemPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + PyObject **arg2 = (PyObject **) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - XdmfDataItem *result = 0 ; + swig::SwigPyIterator *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + arg2 = &obj0; + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_iterator",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_iterator" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); - result = (XdmfDataItem *)((boost::shared_ptr< XdmfDataItem > const *)arg1)->operator ->(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDataItem, 0 | 0 ); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = (swig::SwigPyIterator *)std_vector_Sl_float_Sg__iterator(arg1,arg2); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_XdmfDataItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *result = 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)":new_XdmfDataItemPtr")) SWIG_fail; - result = (boost::shared_ptr< XdmfDataItem > *)new boost::shared_ptr< XdmfDataItem >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_POINTER_NEW | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector___nonzero__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___nonzero__" "', argument " "1"" of type '" "std::vector< float > const *""'"); + } + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = (bool)std_vector_Sl_float_Sg____nonzero__((std::vector< float > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_XdmfDataItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDataItemPtr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector___bool__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDataItemPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___bool__" "', argument " "1"" of type '" "std::vector< float > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); - delete arg1; - resultobj = SWIG_Py_Void(); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = (bool)std_vector_Sl_float_Sg____bool__((std::vector< float > const *)arg1); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - boost::shared_ptr< XdmfDataItem > result; + std::vector< float >::size_type result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_New",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector___len__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___len__" "', argument " "1"" of type '" "std::vector< float > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); - result = (*arg1)->New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfDataItem >(static_cast< const boost::shared_ptr< XdmfDataItem >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = std_vector_Sl_float_Sg____len__((std::vector< float > const *)arg1); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_getNumberValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - int result; + std::vector< float >::value_type result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_getNumberValues",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_pop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_getNumberValues" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_pop" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); - result = (int)(*arg1)->getNumberValues(); - resultobj = SWIG_From_int(static_cast< int >(result)); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + try { + result = (std::vector< float >::value_type)std_vector_Sl_float_Sg__pop(arg1); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_float(static_cast< float >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + std::vector< float >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; - std::string result; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + std::vector< float,std::allocator< float > > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDataItemPtr_printSelf",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___getslice__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); - result = (*arg1)->printSelf(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___getslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = static_cast< std::vector< float >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___getslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'"); + } + arg3 = static_cast< std::vector< float >::difference_type >(val3); + try { + result = (std::vector< float,std::allocator< float > > *)std_vector_Sl_float_Sg____getslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDataItemPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___setslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDataItem > *arg1 = (boost::shared_ptr< XdmfDataItem > *) 0 ; - boost::shared_ptr< XdmfVisitor > arg2 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + std::vector< float >::difference_type arg3 ; + std::vector< float,std::allocator< float > > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; + int res4 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDataItemPtr_write",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDataItemPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDataItem > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___setslice__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDataItem > * >(argp1); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___setslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = static_cast< std::vector< float >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___setslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'"); + } + arg3 = static_cast< std::vector< float >::difference_type >(val3); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDataItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDataItemPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); - } else { - boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; + std::vector > *ptr = (std::vector > *)0; + res4 = swig::asptr(obj3, &ptr); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FloatVector___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'"); } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___setslice__" "', argument " "4"" of type '" "std::vector< float,std::allocator< float > > const &""'"); + } + arg4 = ptr; } - (*arg1)->write(arg2); + try { + std_vector_Sl_float_Sg____setslice__(arg1,arg2,arg3,(std::vector< float,std::allocator< float > > const &)*arg4); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res4)) delete arg4; return resultobj; fail: + if (SWIG_IsNewObj(res4)) delete arg4; return NULL; } -SWIGINTERN PyObject *XdmfDataItemPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfDataItem_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_XdmfDomainPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + std::vector< float >::difference_type arg3 ; void *argp1 = 0 ; int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + ptrdiff_t val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; - XdmfDomain *result = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___delslice__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - result = (XdmfDomain *)((boost::shared_ptr< XdmfDomain > const *)arg1)->operator ->(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfDomain, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_XdmfDomainPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *result = 0 ; - - if (!PyArg_ParseTuple(args,(char *)":new_XdmfDomainPtr")) SWIG_fail; - result = (boost::shared_ptr< XdmfDomain > *)new boost::shared_ptr< XdmfDomain >(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___delslice__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = static_cast< std::vector< float >::difference_type >(val2); + ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___delslice__" "', argument " "3"" of type '" "std::vector< float >::difference_type""'"); + } + arg3 = static_cast< std::vector< float >::difference_type >(val3); + try { + std_vector_Sl_float_Sg____delslice__(arg1,arg2,arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_XdmfDomainPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfDomainPtr",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfDomainPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___delitem__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - delete arg1; + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___delitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = static_cast< std::vector< float >::difference_type >(val2); + try { + std_vector_Sl_float_Sg____delitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4872,129 +26120,210 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - boost::shared_ptr< XdmfDomain > result; + PyObject * obj1 = 0 ; + std::vector< float,std::allocator< float > > *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_New",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___getitem__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - result = (*arg1)->New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfDomain >(static_cast< const boost::shared_ptr< XdmfDomain >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + result = (std::vector< float,std::allocator< float > > *)std_vector_Sl_float_Sg____getitem____SWIG_0(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; - boost::shared_ptr< XdmfGrid > arg2 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; + std::vector< float,std::allocator< float > > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; + int res3 = SWIG_OLDOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_insert",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_insert" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___setitem__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomainPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomainPtr_insert" "', argument " "2"" of type '" "boost::shared_ptr< XdmfGrid >""'"); - } else { - boost::shared_ptr< XdmfGrid > * temp = reinterpret_cast< boost::shared_ptr< XdmfGrid > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; + arg2 = (PySliceObject *) obj1; + } + { + std::vector > *ptr = (std::vector > *)0; + res3 = swig::asptr(obj2, &ptr); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatVector___setitem__" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > > const &""'"); } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatVector___setitem__" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > > const &""'"); + } + arg3 = ptr; } - (*arg1)->insert(arg2); + try { + std_vector_Sl_float_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< float,std::allocator< float > > const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + catch(std::invalid_argument &_e) { + SWIG_exception_fail(SWIG_ValueError, (&_e)->what()); + } + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res3)) delete arg3; return resultobj; fail: + if (SWIG_IsNewObj(res3)) delete arg3; return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; - unsigned int arg2 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + PySliceObject *arg2 = (PySliceObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - unsigned int val2 ; - int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - boost::shared_ptr< XdmfGrid > result; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_getGrid",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___delitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getGrid" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___delitem__" "', argument " "1"" of type '" "std::vector< float > *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomainPtr_getGrid" "', argument " "2"" of type '" "unsigned int""'"); - } - arg2 = static_cast< unsigned int >(val2); - result = (*arg1)->getGrid(arg2); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid >(static_cast< const boost::shared_ptr< XdmfGrid >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t, SWIG_POINTER_OWN | 0 ); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + { + arg2 = (PySliceObject *) obj1; + } + try { + std_vector_Sl_float_Sg____delitem____SWIG_1(arg1,arg2); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___delitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[3]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 2); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + return _wrap_FloatVector___delitem____SWIG_1(self, args); + } + } + } + if (argc == 2) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector___delitem____SWIG_0(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector___delitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __delitem__(std::vector< float > *,std::vector< float >::difference_type)\n" + " __delitem__(std::vector< float > *,PySliceObject *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FloatVector___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; - unsigned int arg2 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; void *argp1 = 0 ; int res1 = 0 ; - unsigned int val2 ; + ptrdiff_t val2 ; int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - SwigValueWrapper< boost::shared_ptr< XdmfGrid const > > result; + std::vector< float >::value_type *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_getGrid",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector___getitem__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getGrid" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___getitem__" "', argument " "1"" of type '" "std::vector< float > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XdmfDomainPtr_getGrid" "', argument " "2"" of type '" "unsigned int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___getitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); } - arg2 = static_cast< unsigned int >(val2); - result = (*arg1)->getGrid(arg2); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGrid const >(static_cast< const boost::shared_ptr< XdmfGrid const >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_const_t, SWIG_POINTER_OWN | 0 ); + arg2 = static_cast< std::vector< float >::difference_type >(val2); + try { + { + std::vector< float >::value_type const &_result_ref = std_vector_Sl_float_Sg____getitem____SWIG_1((std::vector< float > const *)arg1,arg2); + result = (std::vector< float >::value_type *) &_result_ref; + } + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_From_float(static_cast< float >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector___getitem__(PyObject *self, PyObject *args) { int argc; PyObject *argv[3]; int ii; @@ -5006,119 +26335,277 @@ SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getGrid(PyObject *self, PyObject *args) } if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0); + int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); - _v = SWIG_CheckState(res); + _v = PySlice_Check(argv[1]); } if (_v) { - return _wrap_XdmfDomainPtr_getGrid__SWIG_0(self, args); + return _wrap_FloatVector___getitem____SWIG_0(self, args); } } } if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0); + int res = swig::asptr(argv[0], (std::vector >**)(0)); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL); + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_XdmfDomainPtr_getGrid__SWIG_1(self, args); + return _wrap_FloatVector___getitem____SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector___getitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __getitem__(std::vector< float > *,PySliceObject *)\n" + " __getitem__(std::vector< float > const *,std::vector< float >::difference_type)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FloatVector___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::difference_type arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + ptrdiff_t val2 ; + int ecode2 = 0 ; + std::vector< float >::value_type temp3 ; + float val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:FloatVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector___setitem__" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector___setitem__" "', argument " "2"" of type '" "std::vector< float >::difference_type""'"); + } + arg2 = static_cast< std::vector< float >::difference_type >(val2); + ecode3 = SWIG_AsVal_float(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatVector___setitem__" "', argument " "3"" of type '" "std::vector< float >::value_type""'"); + } + temp3 = static_cast< std::vector< float >::value_type >(val3); + arg3 = &temp3; + try { + std_vector_Sl_float_Sg____setitem____SWIG_1(arg1,arg2,(float const &)*arg3); + } + catch(std::out_of_range &_e) { + SWIG_exception_fail(SWIG_IndexError, (&_e)->what()); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FloatVector___setitem__(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PySlice_Check(argv[1]); + } + if (_v) { + int res = swig::asptr(argv[2], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_FloatVector___setitem____SWIG_0(self, args); + } + } + } + } + if (argc == 3) { + int _v; + int res = swig::asptr(argv[0], (std::vector >**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_float(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FloatVector___setitem____SWIG_1(self, args); + } } } } - + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'FloatVector___setitem__'.\n" + " Possible C/C++ prototypes are:\n" + " __setitem__(std::vector< float > *,PySliceObject *,std::vector< float,std::allocator< float > > const &)\n" + " __setitem__(std::vector< float > *,std::vector< float >::difference_type,std::vector< float >::value_type const &)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FloatVector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float >::value_type *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + std::vector< float >::value_type temp2 ; + float val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_append",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_append" "', argument " "1"" of type '" "std::vector< float > *""'"); + } + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + ecode2 = SWIG_AsVal_float(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatVector_append" "', argument " "2"" of type '" "std::vector< float >::value_type""'"); + } + temp2 = static_cast< std::vector< float >::value_type >(val2); + arg2 = &temp2; + std_vector_Sl_float_Sg__append(arg1,(float const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< float > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_FloatVector")) SWIG_fail; + result = (std::vector< float > *)new std::vector< float >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_FloatVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::vector< float > *arg1 = 0 ; + int res1 = SWIG_OLDOBJ ; + PyObject * obj0 = 0 ; + std::vector< float > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:new_FloatVector",&obj0)) SWIG_fail; + { + std::vector > *ptr = (std::vector > *)0; + res1 = swig::asptr(obj0, &ptr); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatVector" "', argument " "1"" of type '" "std::vector< float > const &""'"); + } + arg1 = ptr; + } + result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_NEW | 0 ); + if (SWIG_IsNewObj(res1)) delete arg1; + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'XdmfDomainPtr_getGrid'.\n" - " Possible C/C++ prototypes are:\n" - " getGrid(boost::shared_ptr< XdmfDomain > *,unsigned int)\n" - " getGrid(boost::shared_ptr< XdmfDomain > const *,unsigned int)\n"); + if (SWIG_IsNewObj(res1)) delete arg1; return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_getNumberOfGrids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - unsigned int result; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_getNumberOfGrids",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_empty",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_getNumberOfGrids" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_empty" "', argument " "1"" of type '" "std::vector< float > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - result = (unsigned int)(*arg1)->getNumberOfGrids(); - resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result)); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = (bool)((std::vector< float > const *)arg1)->empty(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; - std::string result; + std::vector< float >::size_type result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfDomainPtr_printSelf",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_size",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_size" "', argument " "1"" of type '" "std::vector< float > const *""'"); } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - result = (*arg1)->printSelf(); - resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + result = ((std::vector< float > const *)arg1)->size(); + resultobj = SWIG_From_size_t(static_cast< size_t >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfDomainPtr_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfDomain > *arg1 = (boost::shared_ptr< XdmfDomain > *) 0 ; - boost::shared_ptr< XdmfVisitor > arg2 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:XdmfDomainPtr_write",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:FloatVector_clear",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfDomainPtr_write" "', argument " "1"" of type '" "boost::shared_ptr< XdmfDomain > const *""'"); - } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfDomain > * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfDomainPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfDomainPtr_write" "', argument " "2"" of type '" "boost::shared_ptr< XdmfVisitor >""'"); - } else { - boost::shared_ptr< XdmfVisitor > * temp = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatVector_clear" "', argument " "1"" of type '" "std::vector< float > *""'"); } - (*arg1)->write(arg2); + arg1 = reinterpret_cast< std::vector< float > * >(argp1); + (arg1)->clear(); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -5126,213 +26613,219 @@ fail: } -SWIGINTERN PyObject *XdmfDomainPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfDomain_t, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_XdmfGeometryPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FloatVector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + std::vector< float > *arg1 = (std::vector< float > *) 0 ; + std::vector< float > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; - XdmfGeometry *result = 0 ; + PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr___deref__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OO:FloatVector_swap",&obj0,&obj1)) SWIG_fail; + res1