From d8f93046bb035e04822568d03c8bc8df1fe99d32 Mon Sep 17 00:00:00 2001
From: Mikhail Svechnikov <m.svechnikov@fz-juelich.de>
Date: Fri, 7 Jul 2023 15:48:35 +0200
Subject: [PATCH] imag profile mplementation
---
Resample/Slice/ProfileHelper.cpp | 58 ++-
Resample/Slice/ProfileHelper.h | 7 +
Resample/Swig/MultiLayerFuncs.cpp | 11 +
Resample/Swig/MultiLayerFuncs.h | 4 +
auto/Examples/varia/MaterialProfile.py | 20 +-
auto/Wrap/libBornAgainBase.py | 64 +--
auto/Wrap/libBornAgainBase_wrap.cpp | 454 +++++++++----------
auto/Wrap/libBornAgainDevice.py | 72 +--
auto/Wrap/libBornAgainDevice_wrap.cpp | 510 ++++++++++-----------
auto/Wrap/libBornAgainFit.py | 64 +--
auto/Wrap/libBornAgainFit_wrap.cpp | 454 +++++++++----------
auto/Wrap/libBornAgainParam.py | 80 ++--
auto/Wrap/libBornAgainParam_wrap.cpp | 566 +++++++++++------------
auto/Wrap/libBornAgainResample.py | 76 ++--
auto/Wrap/libBornAgainResample_wrap.cpp | 570 +++++++++++++-----------
auto/Wrap/libBornAgainSample.py | 80 ++--
auto/Wrap/libBornAgainSample_wrap.cpp | 566 +++++++++++------------
auto/Wrap/libBornAgainSim.py | 80 ++--
auto/Wrap/libBornAgainSim_wrap.cpp | 566 +++++++++++------------
19 files changed, 2220 insertions(+), 2082 deletions(-)
diff --git a/Resample/Slice/ProfileHelper.cpp b/Resample/Slice/ProfileHelper.cpp
index a1acd7a6c0c..19c76a53dc5 100644
--- a/Resample/Slice/ProfileHelper.cpp
+++ b/Resample/Slice/ProfileHelper.cpp
@@ -13,9 +13,11 @@
// ************************************************************************************************
#include "Resample/Slice/ProfileHelper.h"
+#include "Base/Util/Assert.h"
#include "Resample/Slice/SliceStack.h"
#include "Sample/Interface/LayerRoughness.h"
#include <numbers>
+
using std::numbers::pi;
namespace {
@@ -34,6 +36,26 @@ double Transition(double x, double sigma)
return TransitionTanh(x / sigma);
}
+constexpr std::string SLD = "SLD";
+constexpr std::string X = "X";
+constexpr std::string Y = "Y";
+constexpr std::string Z = "Z";
+
+complex_t quantity(const Material& mat, std::string q)
+{
+ if (q == SLD)
+ return mat.refractiveIndex_or_SLD();
+ else if (q == X)
+ return mat.magnetization().x();
+ else if (q == Y)
+ return mat.magnetization().y();
+ else if (q == Z)
+ return mat.magnetization().z();
+ else
+ ASSERT(false);
+ return {};
+}
+
} // namespace
@@ -42,29 +64,49 @@ ProfileHelper::ProfileHelper(const SliceStack& stack)
{
}
-// Note: for refractive index materials, the material interpolation actually happens at the level
-// of n^2. To first order in delta and beta, this implies the same smooth interpolation of delta
-// and beta, as is done here.
-std::vector<complex_t> ProfileHelper::calculateProfile(const std::vector<double>& z_values) const
+std::vector<complex_t> ProfileHelper::profile(const std::vector<double>& z_values,
+ std::string component) const
{
const complex_t top_value =
- !m_stack.empty() ? m_stack.at(0).material().refractiveIndex_or_SLD() : 0.0;
+ !m_stack.empty() ? quantity(m_stack.at(0).material(), component) : 0.0;
std::vector<complex_t> result(z_values.size(), top_value);
for (size_t i = 1; i < m_stack.size(); ++i) {
const Slice& slice = m_stack.at(i);
const Slice& sliceAbove = m_stack.at(i - 1);
- const complex_t sld_diff = slice.material().refractiveIndex_or_SLD()
- - sliceAbove.material().refractiveIndex_or_SLD();
+ const complex_t diff =
+ quantity(slice.material(), component) - quantity(sliceAbove.material(), component);
for (size_t j = 0; j < z_values.size(); ++j) {
const double arg = (z_values[j] - slice.hig());
const LayerRoughness* roughness = slice.topRoughness();
const double t = Transition(arg, roughness ? roughness->sigma() : 0);
- result[j] += sld_diff * t;
+ result[j] += diff * t;
}
}
return result;
}
+// Note: for refractive index materials, the material interpolation actually happens at the level
+// of n^2. To first order in delta and beta, this implies the same smooth interpolation of delta
+// and beta, as is done here.
+std::vector<complex_t> ProfileHelper::calculateProfile(const std::vector<double>& z_values) const
+{
+ return profile(z_values, SLD);
+}
+
+std::vector<double> ProfileHelper::calculateMagneticProfile(const std::vector<double>& z_values,
+ std::string component) const
+{
+ if (component != X && component != Y && component != Z)
+ throw std::runtime_error("Incorrect magnetization component \"" + component + "\".\nOnly \""
+ + X + "\", \"" + Y + "\" or \"" + Z + "\" are allowed.");
+
+ std::vector<complex_t> v = profile(z_values, component);
+ std::vector<double> result(v.size());
+ for (size_t i = 0; i < v.size(); i++)
+ result[i] = real(v[i]);
+ return result;
+}
+
std::pair<double, double> ProfileHelper::defaultLimits() const
{
if (m_stack.size() < 2)
diff --git a/Resample/Slice/ProfileHelper.h b/Resample/Slice/ProfileHelper.h
index 46cbb1abd17..dfa57ea7c42 100644
--- a/Resample/Slice/ProfileHelper.h
+++ b/Resample/Slice/ProfileHelper.h
@@ -20,6 +20,7 @@
#include "Sample/Material/Material.h"
#include <utility>
+#include <variant>
#include <vector>
class SliceStack;
@@ -34,10 +35,16 @@ public:
ProfileHelper(const SliceStack& stack);
~ProfileHelper() = default;
+
std::vector<complex_t> calculateProfile(const std::vector<double>& z_values) const;
+ std::vector<double> calculateMagneticProfile(const std::vector<double>& z_values,
+ std::string component) const;
std::pair<double, double> defaultLimits() const;
private:
+ std::vector<complex_t> profile(const std::vector<double>& z_values,
+ std::string component) const;
+
const SliceStack& m_stack; // from Fresnel map
};
diff --git a/Resample/Swig/MultiLayerFuncs.cpp b/Resample/Swig/MultiLayerFuncs.cpp
index 8fb2027821f..68b880fd6dd 100644
--- a/Resample/Swig/MultiLayerFuncs.cpp
+++ b/Resample/Swig/MultiLayerFuncs.cpp
@@ -39,6 +39,17 @@ std::vector<complex_t> swigAPI::materialProfileSLD(const MultiLayer& sample, int
return helper.calculateProfile(z_values);
}
+std::vector<double> swigAPI::magnetizationProfile(const MultiLayer& sample, std::string component,
+ int n_points, double z_min, double z_max)
+{
+ SimulationOptions options;
+ options.setUseAvgMaterials(true);
+ const ReSample resample = ReSample::make(sample, options);
+ ProfileHelper helper(resample.averageSlices());
+ std::vector<double> z_values = generateZValues(n_points, z_min, z_max);
+ return helper.calculateMagneticProfile(z_values, component);
+}
+
std::pair<double, double> swigAPI::defaultMaterialProfileLimits(const MultiLayer& sample)
{
SimulationOptions options;
diff --git a/Resample/Swig/MultiLayerFuncs.h b/Resample/Swig/MultiLayerFuncs.h
index 45ce69ee62c..74d155becd1 100644
--- a/Resample/Swig/MultiLayerFuncs.h
+++ b/Resample/Swig/MultiLayerFuncs.h
@@ -31,6 +31,10 @@ std::vector<double> generateZValues(int n_points, double z_min, double z_max);
std::vector<complex_t> materialProfileSLD(const MultiLayer& sample, int n_points, double z_min,
double z_max);
+//! Calculate average magnetization profile for given sample
+std::vector<double> magnetizationProfile(const MultiLayer& sample, std::string component,
+ int n_points, double z_min, double z_max);
+
//! Get default z limits for generating a material profile
std::pair<double, double> defaultMaterialProfileLimits(const MultiLayer& sample);
diff --git a/auto/Examples/varia/MaterialProfile.py b/auto/Examples/varia/MaterialProfile.py
index b930daaf389..80650e2ec17 100755
--- a/auto/Examples/varia/MaterialProfile.py
+++ b/auto/Examples/varia/MaterialProfile.py
@@ -4,7 +4,7 @@ Plot an SLD profile for a multilayer sample with rough interfaces.
"""
import bornagain as ba
-from bornagain import angstrom, ba_plot as bp, sample_tools
+from bornagain import angstrom, ba_plot as bp, sample_tools, R3
import numpy as np
import matplotlib.pyplot as plt
@@ -12,8 +12,8 @@ import matplotlib.pyplot as plt
def get_sample():
# materials
vacuum = ba.MaterialBySLD("Vacuum", 0, 0)
- material_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0)
- material_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0)
+ material_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0, R3(1,-1,0))
+ material_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0, R3(0.3,1,0))
material_substrate = ba.MaterialBySLD("SiSubstrate", 2.0704e-06, 0)
# layers
@@ -33,12 +33,22 @@ def get_sample():
return sample
+def magnetizationProfile(sample, n_points=400, z_min=None, z_max=None):
+ def_z_min, def_z_max = ba.defaultMaterialProfileLimits(sample)
+ z_min = def_z_min if z_min is None else z_min
+ z_max = def_z_max if z_max is None else z_max
+ z_points = ba.generateZValues(n_points, z_min, z_max)
+ magnetization_values = ba.magnetizationProfile(sample, "w", n_points, z_min, z_max)
+ return (z_points, magnetization_values)
if __name__ == '__main__':
sample = get_sample()
- zpoints, slds = sample_tools.materialProfile(sample, 400)
+ # zpoints, slds = sample_tools.materialProfile(sample, 400)
+ # plt.figure()
+ # plt.plot(zpoints, np.real(slds))
+ zpoints, mag = magnetizationProfile(sample, 400)
plt.figure()
- plt.plot(zpoints, np.real(slds))
+ plt.plot(zpoints, mag)
bp.show_or_export()
diff --git a/auto/Wrap/libBornAgainBase.py b/auto/Wrap/libBornAgainBase.py
index 27d071da8f6..f130357937b 100644
--- a/auto/Wrap/libBornAgainBase.py
+++ b/auto/Wrap/libBornAgainBase.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainBase.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainBase.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainBase.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainBase.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainBase.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainBase.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainBase.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainBase.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainBase.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainBase.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainBase.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainBase.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainBase.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainBase.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainBase.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainBase.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainBase.vector_pvacuum_double_t___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainBase_wrap.cpp b/auto/Wrap/libBornAgainBase_wrap.cpp
index e9cdd8146ce..81dc8c456c3 100644
--- a/auto/Wrap/libBornAgainBase_wrap.cpp
+++ b/auto/Wrap/libBornAgainBase_wrap.cpp
@@ -3602,9 +3602,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5417,46 +5417,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5553,46 +5553,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5690,46 +5690,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5791,46 +5791,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5912,46 +5912,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5996,7 +5996,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6064,46 +6064,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6388,46 +6388,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6917,46 +6917,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8215,7 +8215,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8228,9 +8228,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8249,7 +8249,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8263,9 +8263,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8297,7 +8297,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8309,9 +8309,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8330,7 +8330,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8342,9 +8342,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8400,7 +8400,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8478,7 +8478,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -8588,8 +8588,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10039,7 +10039,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10052,9 +10052,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10073,7 +10073,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10087,9 +10087,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10121,7 +10121,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10133,9 +10133,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10154,7 +10154,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10166,9 +10166,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10224,7 +10224,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10302,7 +10302,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10415,8 +10415,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -11893,7 +11893,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -11906,9 +11906,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -11927,7 +11927,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -11941,9 +11941,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -11975,7 +11975,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -11987,9 +11987,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12008,7 +12008,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12020,9 +12020,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12078,7 +12078,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12156,7 +12156,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12266,8 +12266,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -13717,7 +13717,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -13730,9 +13730,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -13751,7 +13751,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13765,9 +13765,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -13799,7 +13799,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13811,9 +13811,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -13832,7 +13832,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13844,9 +13844,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -13902,7 +13902,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -13980,7 +13980,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14093,8 +14093,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -15571,7 +15571,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -15584,9 +15584,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -15605,7 +15605,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15619,9 +15619,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -15653,7 +15653,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15665,9 +15665,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -15686,7 +15686,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15698,9 +15698,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -15756,7 +15756,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -15834,7 +15834,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -15944,8 +15944,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17395,7 +17395,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17408,9 +17408,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17429,7 +17429,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17443,9 +17443,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17477,7 +17477,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17489,9 +17489,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17510,7 +17510,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17522,9 +17522,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -17580,7 +17580,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -17658,7 +17658,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -17768,8 +17768,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19219,7 +19219,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19232,9 +19232,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19253,7 +19253,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19267,9 +19267,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19301,7 +19301,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19313,9 +19313,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19334,7 +19334,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19346,9 +19346,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19404,7 +19404,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19482,7 +19482,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -19595,8 +19595,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22535,7 +22535,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22548,9 +22548,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -22569,7 +22569,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22583,9 +22583,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -22617,7 +22617,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22629,9 +22629,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -22650,7 +22650,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22662,9 +22662,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -22720,7 +22720,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -22798,7 +22798,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -22911,8 +22911,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -27902,15 +27902,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -27964,15 +27964,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -28026,15 +28026,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -28088,15 +28088,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -28150,15 +28150,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -28212,15 +28212,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -28274,15 +28274,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -28392,15 +28392,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
diff --git a/auto/Wrap/libBornAgainDevice.py b/auto/Wrap/libBornAgainDevice.py
index 40dec146a06..c7c2bad132a 100644
--- a/auto/Wrap/libBornAgainDevice.py
+++ b/auto/Wrap/libBornAgainDevice.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainDevice.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainDevice.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainDevice.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainDevice.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainDevice.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainDevice.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainDevice.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainDevice.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainDevice.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainDevice.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainDevice.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainDevice.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainDevice.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainDevice.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainDevice.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainDevice.vector_pvacuum_double_t___setitem__(self, *args)
@@ -1908,21 +1908,21 @@ class vector_R3(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
- __delitem__(vector_R3 self, PySliceObject * slice)
+ __delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainDevice.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
+ __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3
__getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
"""
return _libBornAgainDevice.vector_R3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
- __setitem__(vector_R3 self, PySliceObject * slice)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
"""
return _libBornAgainDevice.vector_R3___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainDevice_wrap.cpp b/auto/Wrap/libBornAgainDevice_wrap.cpp
index df19730304c..b6696b84c25 100644
--- a/auto/Wrap/libBornAgainDevice_wrap.cpp
+++ b/auto/Wrap/libBornAgainDevice_wrap.cpp
@@ -3638,9 +3638,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5453,46 +5453,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5589,46 +5589,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5726,46 +5726,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5827,46 +5827,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5948,46 +5948,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6032,7 +6032,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6100,46 +6100,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6424,46 +6424,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6953,46 +6953,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7085,46 +7085,46 @@ SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delslice__(std::vector< V
SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< Vec3< double > > *self,std::vector< Vec3< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8362,7 +8362,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8375,9 +8375,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8396,7 +8396,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8410,9 +8410,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8444,7 +8444,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8456,9 +8456,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8477,7 +8477,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8489,9 +8489,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8547,7 +8547,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8625,7 +8625,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -8735,8 +8735,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10186,7 +10186,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10199,9 +10199,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10220,7 +10220,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10234,9 +10234,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10268,7 +10268,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10280,9 +10280,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10301,7 +10301,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10313,9 +10313,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10371,7 +10371,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10449,7 +10449,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10562,8 +10562,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -12040,7 +12040,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -12053,9 +12053,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -12074,7 +12074,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12088,9 +12088,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12122,7 +12122,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12134,9 +12134,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12155,7 +12155,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12167,9 +12167,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12225,7 +12225,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12303,7 +12303,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12413,8 +12413,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -13864,7 +13864,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -13877,9 +13877,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -13898,7 +13898,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13912,9 +13912,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -13946,7 +13946,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13958,9 +13958,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -13979,7 +13979,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13991,9 +13991,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -14049,7 +14049,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14127,7 +14127,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14240,8 +14240,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -15718,7 +15718,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -15731,9 +15731,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -15752,7 +15752,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15766,9 +15766,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -15800,7 +15800,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15812,9 +15812,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -15833,7 +15833,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15845,9 +15845,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -15903,7 +15903,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -15981,7 +15981,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16091,8 +16091,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17542,7 +17542,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17555,9 +17555,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17576,7 +17576,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17590,9 +17590,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17624,7 +17624,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17636,9 +17636,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17657,7 +17657,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17669,9 +17669,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -17727,7 +17727,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -17805,7 +17805,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -17915,8 +17915,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19366,7 +19366,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19379,9 +19379,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19400,7 +19400,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19414,9 +19414,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19448,7 +19448,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19460,9 +19460,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19481,7 +19481,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19493,9 +19493,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19551,7 +19551,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19629,7 +19629,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -19742,8 +19742,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22682,7 +22682,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22695,9 +22695,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -22716,7 +22716,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22730,9 +22730,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -22764,7 +22764,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22776,9 +22776,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -22797,7 +22797,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22809,9 +22809,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -22867,7 +22867,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -22945,7 +22945,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -23058,8 +23058,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -25918,7 +25918,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *result = 0 ;
@@ -25931,9 +25931,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -25952,7 +25952,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -25966,9 +25966,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *ptr = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)0;
@@ -26000,7 +26000,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26012,9 +26012,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -26033,7 +26033,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26045,9 +26045,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -26103,7 +26103,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< Vec3< double > >::__delitem__(std::vector< Vec3< double > >::difference_type)\n"
- " std::vector< Vec3< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< Vec3< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -26181,7 +26181,7 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__getitem__(std::vector< Vec3< double > >::difference_type) const\n");
return 0;
}
@@ -26290,8 +26290,8 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__setitem__(std::vector< Vec3< double > >::difference_type,std::vector< Vec3< double > >::value_type const &)\n");
return 0;
}
@@ -37807,15 +37807,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -37869,15 +37869,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -37931,15 +37931,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -37993,15 +37993,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -38055,15 +38055,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -38117,15 +38117,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -38179,15 +38179,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -38297,15 +38297,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
@@ -38415,15 +38415,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3___delslice__", _wrap_vector_R3___delslice__, METH_VARARGS, "vector_R3___delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"},
{ "vector_R3___delitem__", _wrap_vector_R3___delitem__, METH_VARARGS, "\n"
"vector_R3___delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)\n"
- "vector_R3___delitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_R3___getitem__", _wrap_vector_R3___getitem__, METH_VARARGS, "\n"
- "vector_R3___getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3\n"
+ "vector_R3___getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3\n"
"vector_R3___getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3\n"
""},
{ "vector_R3___setitem__", _wrap_vector_R3___setitem__, METH_VARARGS, "\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_R3___setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)\n"
""},
{ "vector_R3_pop", _wrap_vector_R3_pop, METH_O, "vector_R3_pop(vector_R3 self) -> R3"},
diff --git a/auto/Wrap/libBornAgainFit.py b/auto/Wrap/libBornAgainFit.py
index 0a6d5ebba17..3da65c51ee2 100644
--- a/auto/Wrap/libBornAgainFit.py
+++ b/auto/Wrap/libBornAgainFit.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainFit.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainFit.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainFit.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainFit.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainFit.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainFit.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainFit.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainFit.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainFit.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainFit.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainFit.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainFit.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainFit.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainFit.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainFit.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainFit.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainFit.vector_pvacuum_double_t___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainFit_wrap.cpp b/auto/Wrap/libBornAgainFit_wrap.cpp
index 564bd7a6a68..70f8897d16e 100644
--- a/auto/Wrap/libBornAgainFit_wrap.cpp
+++ b/auto/Wrap/libBornAgainFit_wrap.cpp
@@ -3606,9 +3606,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5421,46 +5421,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5557,46 +5557,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5694,46 +5694,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5795,46 +5795,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5916,46 +5916,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6000,7 +6000,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6068,46 +6068,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6392,46 +6392,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6921,46 +6921,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8286,7 +8286,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8299,9 +8299,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8320,7 +8320,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8334,9 +8334,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8368,7 +8368,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8380,9 +8380,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8401,7 +8401,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8413,9 +8413,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8471,7 +8471,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8549,7 +8549,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -8659,8 +8659,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10110,7 +10110,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10123,9 +10123,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10144,7 +10144,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10158,9 +10158,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10192,7 +10192,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10204,9 +10204,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10225,7 +10225,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10237,9 +10237,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10295,7 +10295,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10373,7 +10373,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10486,8 +10486,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -11964,7 +11964,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -11977,9 +11977,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -11998,7 +11998,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12012,9 +12012,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12046,7 +12046,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12058,9 +12058,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12079,7 +12079,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12091,9 +12091,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12149,7 +12149,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12227,7 +12227,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12337,8 +12337,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -13788,7 +13788,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -13801,9 +13801,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -13822,7 +13822,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13836,9 +13836,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -13870,7 +13870,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13882,9 +13882,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -13903,7 +13903,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13915,9 +13915,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -13973,7 +13973,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14051,7 +14051,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14164,8 +14164,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -15642,7 +15642,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -15655,9 +15655,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -15676,7 +15676,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15690,9 +15690,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -15724,7 +15724,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15736,9 +15736,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -15757,7 +15757,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15769,9 +15769,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -15827,7 +15827,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -15905,7 +15905,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16015,8 +16015,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17466,7 +17466,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17479,9 +17479,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17500,7 +17500,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17514,9 +17514,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17548,7 +17548,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17560,9 +17560,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17581,7 +17581,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17593,9 +17593,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -17651,7 +17651,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -17729,7 +17729,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -17839,8 +17839,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19290,7 +19290,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19303,9 +19303,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19324,7 +19324,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19338,9 +19338,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19372,7 +19372,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19384,9 +19384,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19405,7 +19405,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19417,9 +19417,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19475,7 +19475,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19553,7 +19553,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -19666,8 +19666,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22606,7 +22606,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22619,9 +22619,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -22640,7 +22640,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22654,9 +22654,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -22688,7 +22688,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22700,9 +22700,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -22721,7 +22721,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22733,9 +22733,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -22791,7 +22791,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -22869,7 +22869,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -22982,8 +22982,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -28081,15 +28081,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -28143,15 +28143,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -28205,15 +28205,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -28267,15 +28267,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -28329,15 +28329,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -28391,15 +28391,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -28453,15 +28453,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -28571,15 +28571,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
diff --git a/auto/Wrap/libBornAgainParam.py b/auto/Wrap/libBornAgainParam.py
index a8eb8a1edb1..f244406722f 100644
--- a/auto/Wrap/libBornAgainParam.py
+++ b/auto/Wrap/libBornAgainParam.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainParam.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainParam.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainParam.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainParam.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainParam.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainParam.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainParam.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainParam.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainParam.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainParam.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainParam.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainParam.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainParam.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainParam.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainParam.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainParam.vector_pvacuum_double_t___setitem__(self, *args)
@@ -1707,21 +1707,21 @@ class swig_dummy_type_const_inode_vector(object):
def __delitem__(self, *args):
r"""
__delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)
- __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.swig_dummy_type_const_inode_vector___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
__getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode
"""
return _libBornAgainParam.swig_dummy_type_const_inode_vector___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
__setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)
"""
return _libBornAgainParam.swig_dummy_type_const_inode_vector___setitem__(self, *args)
@@ -1873,21 +1873,21 @@ class vector_parsample_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i)
- __delitem__(vector_parsample_t self, PySliceObject * slice)
+ __delitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainParam.vector_parsample_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_parsample_t self, PySliceObject * slice) -> vector_parsample_t
+ __getitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice) -> vector_parsample_t
__getitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i) -> ParameterSample
"""
return _libBornAgainParam.vector_parsample_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_parsample_t self, PySliceObject * slice, vector_parsample_t v)
- __setitem__(vector_parsample_t self, PySliceObject * slice)
+ __setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice, vector_parsample_t v)
+ __setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, ParameterSample x)
"""
return _libBornAgainParam.vector_parsample_t___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainParam_wrap.cpp b/auto/Wrap/libBornAgainParam_wrap.cpp
index e0553d7ef58..e61c1967d2e 100644
--- a/auto/Wrap/libBornAgainParam_wrap.cpp
+++ b/auto/Wrap/libBornAgainParam_wrap.cpp
@@ -3605,9 +3605,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5420,46 +5420,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5556,46 +5556,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5693,46 +5693,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5794,46 +5794,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5915,46 +5915,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5999,7 +5999,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6067,46 +6067,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6391,46 +6391,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6920,46 +6920,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7034,46 +7034,46 @@ SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delslice__(std::vector< I
SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_0(std::vector< INode const * > *self,std::vector< INode const * >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7143,46 +7143,46 @@ SWIGINTERN void std_vector_Sl_ParameterSample_Sg____delslice__(std::vector< Para
SWIGINTERN void std_vector_Sl_ParameterSample_Sg____delitem____SWIG_0(std::vector< ParameterSample > *self,std::vector< ParameterSample >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< ParameterSample,std::allocator< ParameterSample > > *std_vector_Sl_ParameterSample_Sg____getitem____SWIG_0(std::vector< ParameterSample > *self,PySliceObject *slice){
+SWIGINTERN std::vector< ParameterSample,std::allocator< ParameterSample > > *std_vector_Sl_ParameterSample_Sg____getitem____SWIG_0(std::vector< ParameterSample > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type id = i;
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_0(std::vector< ParameterSample > *self,PySliceObject *slice,std::vector< ParameterSample,std::allocator< ParameterSample > > const &v){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_0(std::vector< ParameterSample > *self,SWIGPY_SLICEOBJECT *slice,std::vector< ParameterSample,std::allocator< ParameterSample > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type id = i;
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_1(std::vector< ParameterSample > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_1(std::vector< ParameterSample > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type id = i;
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_ParameterSample_Sg____delitem____SWIG_1(std::vector< ParameterSample > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____delitem____SWIG_1(std::vector< ParameterSample > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type id = i;
std::vector< ParameterSample,std::allocator< ParameterSample > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8550,7 +8550,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8563,9 +8563,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8584,7 +8584,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8598,9 +8598,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8632,7 +8632,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8644,9 +8644,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8665,7 +8665,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8677,9 +8677,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8735,7 +8735,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8813,7 +8813,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -8923,8 +8923,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10374,7 +10374,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10387,9 +10387,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10408,7 +10408,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10422,9 +10422,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10456,7 +10456,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10468,9 +10468,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10489,7 +10489,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10501,9 +10501,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10559,7 +10559,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10637,7 +10637,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10750,8 +10750,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -12228,7 +12228,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -12241,9 +12241,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -12262,7 +12262,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12276,9 +12276,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12310,7 +12310,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12322,9 +12322,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12343,7 +12343,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12355,9 +12355,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12413,7 +12413,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12491,7 +12491,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12601,8 +12601,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -14052,7 +14052,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -14065,9 +14065,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -14086,7 +14086,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14100,9 +14100,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -14134,7 +14134,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14146,9 +14146,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -14167,7 +14167,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14179,9 +14179,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -14237,7 +14237,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14315,7 +14315,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14428,8 +14428,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -15906,7 +15906,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -15919,9 +15919,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -15940,7 +15940,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15954,9 +15954,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -15988,7 +15988,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16000,9 +16000,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -16021,7 +16021,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16033,9 +16033,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -16091,7 +16091,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -16169,7 +16169,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16279,8 +16279,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17730,7 +17730,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17743,9 +17743,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17764,7 +17764,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17778,9 +17778,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17812,7 +17812,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17824,9 +17824,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17845,7 +17845,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17857,9 +17857,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -17915,7 +17915,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -17993,7 +17993,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -18103,8 +18103,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19554,7 +19554,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19567,9 +19567,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19588,7 +19588,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19602,9 +19602,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19636,7 +19636,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19648,9 +19648,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19669,7 +19669,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19681,9 +19681,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19739,7 +19739,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19817,7 +19817,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -19930,8 +19930,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22870,7 +22870,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22883,9 +22883,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -22904,7 +22904,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22918,9 +22918,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -22952,7 +22952,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22964,9 +22964,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -22985,7 +22985,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22997,9 +22997,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -23055,7 +23055,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -23133,7 +23133,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -23246,8 +23246,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -24724,7 +24724,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< INode const *,std::allocator< INode const * > > *result = 0 ;
@@ -24737,9 +24737,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< INode const *,std::allocator< INode const * > > *)std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(arg1,arg2);
@@ -24758,7 +24758,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< INode const *,std::allocator< INode const * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -24772,9 +24772,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< INode const*,std::allocator< INode const * > > *ptr = (std::vector< INode const*,std::allocator< INode const * > > *)0;
@@ -24806,7 +24806,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -24818,9 +24818,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(arg1,arg2);
@@ -24839,7 +24839,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -24851,9 +24851,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(arg1,arg2);
@@ -24909,7 +24909,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< INode const * >::__delitem__(std::vector< INode const * >::difference_type)\n"
- " std::vector< INode const * >::__delitem__(PySliceObject *)\n");
+ " std::vector< INode const * >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -24986,7 +24986,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__getitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__getitem__(std::vector< INode const * >::difference_type)\n");
return 0;
}
@@ -25093,8 +25093,8 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__setitem__(std::vector< INode const * >::difference_type,std::vector< INode const * >::value_type)\n");
return 0;
}
@@ -26524,7 +26524,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_parsample_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< ParameterSample > *arg1 = (std::vector< ParameterSample > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< ParameterSample,std::allocator< ParameterSample > > *result = 0 ;
@@ -26537,9 +26537,9 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___getitem____SWIG_0(PyObject *self
arg1 = reinterpret_cast< std::vector< ParameterSample > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< ParameterSample,std::allocator< ParameterSample > > *)std_vector_Sl_ParameterSample_Sg____getitem____SWIG_0(arg1,arg2);
@@ -26558,7 +26558,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_parsample_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< ParameterSample > *arg1 = (std::vector< ParameterSample > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< ParameterSample,std::allocator< ParameterSample > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26572,9 +26572,9 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___setitem____SWIG_0(PyObject *self
arg1 = reinterpret_cast< std::vector< ParameterSample > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< ParameterSample,std::allocator< ParameterSample > > *ptr = (std::vector< ParameterSample,std::allocator< ParameterSample > > *)0;
@@ -26606,7 +26606,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_parsample_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< ParameterSample > *arg1 = (std::vector< ParameterSample > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26618,9 +26618,9 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___setitem____SWIG_1(PyObject *self
arg1 = reinterpret_cast< std::vector< ParameterSample > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_ParameterSample_Sg____setitem____SWIG_1(arg1,arg2);
@@ -26639,7 +26639,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_parsample_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< ParameterSample > *arg1 = (std::vector< ParameterSample > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26651,9 +26651,9 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___delitem____SWIG_1(PyObject *self
arg1 = reinterpret_cast< std::vector< ParameterSample > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_ParameterSample_Sg____delitem____SWIG_1(arg1,arg2);
@@ -26709,7 +26709,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_parsample_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< ParameterSample >::__delitem__(std::vector< ParameterSample >::difference_type)\n"
- " std::vector< ParameterSample >::__delitem__(PySliceObject *)\n");
+ " std::vector< ParameterSample >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -26787,7 +26787,7 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___getitem__(PyObject *self, PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_parsample_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< ParameterSample >::__getitem__(PySliceObject *)\n"
+ " std::vector< ParameterSample >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< ParameterSample >::__getitem__(std::vector< ParameterSample >::difference_type) const\n");
return 0;
}
@@ -26896,8 +26896,8 @@ SWIGINTERN PyObject *_wrap_vector_parsample_t___setitem__(PyObject *self, PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_parsample_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< ParameterSample >::__setitem__(PySliceObject *,std::vector< ParameterSample,std::allocator< ParameterSample > > const &)\n"
- " std::vector< ParameterSample >::__setitem__(PySliceObject *)\n"
+ " std::vector< ParameterSample >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< ParameterSample,std::allocator< ParameterSample > > const &)\n"
+ " std::vector< ParameterSample >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< ParameterSample >::__setitem__(std::vector< ParameterSample >::difference_type,std::vector< ParameterSample >::value_type const &)\n");
return 0;
}
@@ -30941,15 +30941,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -31003,15 +31003,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -31065,15 +31065,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -31127,15 +31127,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -31189,15 +31189,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -31251,15 +31251,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -31313,15 +31313,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -31431,15 +31431,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
@@ -31493,15 +31493,15 @@ static PyMethodDef SwigMethods[] = {
{ "swig_dummy_type_const_inode_vector___delslice__", _wrap_swig_dummy_type_const_inode_vector___delslice__, METH_VARARGS, "swig_dummy_type_const_inode_vector___delslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)"},
{ "swig_dummy_type_const_inode_vector___delitem__", _wrap_swig_dummy_type_const_inode_vector___delitem__, METH_VARARGS, "\n"
"swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)\n"
- "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "swig_dummy_type_const_inode_vector___getitem__", _wrap_swig_dummy_type_const_inode_vector___getitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector\n"
+ "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector\n"
"swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode\n"
""},
{ "swig_dummy_type_const_inode_vector___setitem__", _wrap_swig_dummy_type_const_inode_vector___setitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
"swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)\n"
""},
{ "swig_dummy_type_const_inode_vector_pop", _wrap_swig_dummy_type_const_inode_vector_pop, METH_O, "swig_dummy_type_const_inode_vector_pop(swig_dummy_type_const_inode_vector self) -> INode"},
@@ -31555,15 +31555,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_parsample_t___delslice__", _wrap_vector_parsample_t___delslice__, METH_VARARGS, "vector_parsample_t___delslice__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, std::vector< ParameterSample >::difference_type j)"},
{ "vector_parsample_t___delitem__", _wrap_vector_parsample_t___delitem__, METH_VARARGS, "\n"
"vector_parsample_t___delitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i)\n"
- "vector_parsample_t___delitem__(vector_parsample_t self, PySliceObject * slice)\n"
+ "vector_parsample_t___delitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_parsample_t___getitem__", _wrap_vector_parsample_t___getitem__, METH_VARARGS, "\n"
- "vector_parsample_t___getitem__(vector_parsample_t self, PySliceObject * slice) -> vector_parsample_t\n"
+ "vector_parsample_t___getitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice) -> vector_parsample_t\n"
"vector_parsample_t___getitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i) -> ParameterSample\n"
""},
{ "vector_parsample_t___setitem__", _wrap_vector_parsample_t___setitem__, METH_VARARGS, "\n"
- "vector_parsample_t___setitem__(vector_parsample_t self, PySliceObject * slice, vector_parsample_t v)\n"
- "vector_parsample_t___setitem__(vector_parsample_t self, PySliceObject * slice)\n"
+ "vector_parsample_t___setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice, vector_parsample_t v)\n"
+ "vector_parsample_t___setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_parsample_t___setitem__(vector_parsample_t self, std::vector< ParameterSample >::difference_type i, ParameterSample x)\n"
""},
{ "vector_parsample_t_pop", _wrap_vector_parsample_t_pop, METH_O, "vector_parsample_t_pop(vector_parsample_t self) -> ParameterSample"},
diff --git a/auto/Wrap/libBornAgainResample.py b/auto/Wrap/libBornAgainResample.py
index 7c69e8c52c0..ef5b7b469e6 100644
--- a/auto/Wrap/libBornAgainResample.py
+++ b/auto/Wrap/libBornAgainResample.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainResample.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainResample.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainResample.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainResample.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainResample.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainResample.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainResample.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainResample.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainResample.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainResample.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainResample.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainResample.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainResample.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainResample.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainResample.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainResample.vector_pvacuum_double_t___setitem__(self, *args)
@@ -1940,21 +1940,21 @@ class vector_R3(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
- __delitem__(vector_R3 self, PySliceObject * slice)
+ __delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainResample.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
+ __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3
__getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
"""
return _libBornAgainResample.vector_R3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
- __setitem__(vector_R3 self, PySliceObject * slice)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
"""
return _libBornAgainResample.vector_R3___setitem__(self, *args)
@@ -2073,6 +2073,10 @@ def materialProfileSLD(sample, n_points, z_min, z_max):
r"""materialProfileSLD(MultiLayer const & sample, int n_points, double z_min, double z_max) -> vector_complex_t"""
return _libBornAgainResample.materialProfileSLD(sample, n_points, z_min, z_max)
+def magnetizationProfile(sample, component, n_points, z_min, z_max):
+ r"""magnetizationProfile(MultiLayer const & sample, std::string component, int n_points, double z_min, double z_max) -> vdouble1d_t"""
+ return _libBornAgainResample.magnetizationProfile(sample, component, n_points, z_min, z_max)
+
def defaultMaterialProfileLimits(sample):
r"""defaultMaterialProfileLimits(MultiLayer const & sample) -> pvacuum_double_t"""
return _libBornAgainResample.defaultMaterialProfileLimits(sample)
diff --git a/auto/Wrap/libBornAgainResample_wrap.cpp b/auto/Wrap/libBornAgainResample_wrap.cpp
index e9b9628aee8..27bef78f668 100644
--- a/auto/Wrap/libBornAgainResample_wrap.cpp
+++ b/auto/Wrap/libBornAgainResample_wrap.cpp
@@ -3596,9 +3596,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5411,46 +5411,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5547,46 +5547,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5684,46 +5684,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5785,46 +5785,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5906,46 +5906,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5990,7 +5990,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6058,46 +6058,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6382,46 +6382,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6911,46 +6911,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7041,46 +7041,46 @@ SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delslice__(std::vector< V
SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< Vec3< double > > *self,std::vector< Vec3< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8301,7 +8301,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8314,9 +8314,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8335,7 +8335,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8349,9 +8349,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8383,7 +8383,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8395,9 +8395,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8416,7 +8416,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8428,9 +8428,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8486,7 +8486,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8564,7 +8564,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -8674,8 +8674,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10125,7 +10125,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10138,9 +10138,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10159,7 +10159,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10173,9 +10173,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10207,7 +10207,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10219,9 +10219,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10240,7 +10240,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10252,9 +10252,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10310,7 +10310,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10388,7 +10388,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10501,8 +10501,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -11979,7 +11979,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -11992,9 +11992,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -12013,7 +12013,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12027,9 +12027,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12061,7 +12061,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12073,9 +12073,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12094,7 +12094,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12106,9 +12106,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12164,7 +12164,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12242,7 +12242,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12352,8 +12352,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -13803,7 +13803,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -13816,9 +13816,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -13837,7 +13837,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13851,9 +13851,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -13885,7 +13885,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13897,9 +13897,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -13918,7 +13918,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -13930,9 +13930,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -13988,7 +13988,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14066,7 +14066,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14179,8 +14179,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -15657,7 +15657,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -15670,9 +15670,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -15691,7 +15691,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15705,9 +15705,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -15739,7 +15739,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15751,9 +15751,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -15772,7 +15772,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -15784,9 +15784,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -15842,7 +15842,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -15920,7 +15920,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16030,8 +16030,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17481,7 +17481,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17494,9 +17494,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17515,7 +17515,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17529,9 +17529,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17563,7 +17563,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17575,9 +17575,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17596,7 +17596,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17608,9 +17608,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -17666,7 +17666,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -17744,7 +17744,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -17854,8 +17854,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19305,7 +19305,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19318,9 +19318,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19339,7 +19339,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19353,9 +19353,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19387,7 +19387,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19399,9 +19399,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19420,7 +19420,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19432,9 +19432,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19490,7 +19490,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19568,7 +19568,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -19681,8 +19681,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22621,7 +22621,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22634,9 +22634,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -22655,7 +22655,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22669,9 +22669,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -22703,7 +22703,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22715,9 +22715,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -22736,7 +22736,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -22748,9 +22748,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -22806,7 +22806,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -22884,7 +22884,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -22997,8 +22997,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -26167,7 +26167,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *result = 0 ;
@@ -26180,9 +26180,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -26201,7 +26201,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26215,9 +26215,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *ptr = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)0;
@@ -26249,7 +26249,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26261,9 +26261,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -26282,7 +26282,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26294,9 +26294,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -26352,7 +26352,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< Vec3< double > >::__delitem__(std::vector< Vec3< double > >::difference_type)\n"
- " std::vector< Vec3< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< Vec3< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -26430,7 +26430,7 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__getitem__(std::vector< Vec3< double > >::difference_type) const\n");
return 0;
}
@@ -26539,8 +26539,8 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__setitem__(std::vector< Vec3< double > >::difference_type,std::vector< Vec3< double > >::value_type const &)\n");
return 0;
}
@@ -27697,6 +27697,65 @@ fail:
}
+SWIGINTERN PyObject *_wrap_magnetizationProfile(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ MultiLayer *arg1 = 0 ;
+ std::string arg2 ;
+ int arg3 ;
+ double arg4 ;
+ double arg5 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
+ std::vector< double,std::allocator< double > > result;
+
+ if (!SWIG_Python_UnpackTuple(args, "magnetizationProfile", 5, 5, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_MultiLayer, 0 | 0);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "magnetizationProfile" "', argument " "1"" of type '" "MultiLayer const &""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "magnetizationProfile" "', argument " "1"" of type '" "MultiLayer const &""'");
+ }
+ arg1 = reinterpret_cast< MultiLayer * >(argp1);
+ {
+ std::string *ptr = (std::string *)0;
+ int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
+ if (!SWIG_IsOK(res) || !ptr) {
+ SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "magnetizationProfile" "', argument " "2"" of type '" "std::string""'");
+ }
+ arg2 = *ptr;
+ if (SWIG_IsNewObj(res)) delete ptr;
+ }
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "magnetizationProfile" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = static_cast< int >(val3);
+ ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "magnetizationProfile" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = static_cast< double >(val4);
+ ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "magnetizationProfile" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = static_cast< double >(val5);
+ result = swigAPI::magnetizationProfile((MultiLayer const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
+ resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_defaultMaterialProfileLimits(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
MultiLayer *arg1 = 0 ;
@@ -27757,15 +27816,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -27819,15 +27878,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -27881,15 +27940,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -27943,15 +28002,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -28005,15 +28064,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -28067,15 +28126,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -28129,15 +28188,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -28247,15 +28306,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
@@ -28374,15 +28433,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3___delslice__", _wrap_vector_R3___delslice__, METH_VARARGS, "vector_R3___delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"},
{ "vector_R3___delitem__", _wrap_vector_R3___delitem__, METH_VARARGS, "\n"
"vector_R3___delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)\n"
- "vector_R3___delitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_R3___getitem__", _wrap_vector_R3___getitem__, METH_VARARGS, "\n"
- "vector_R3___getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3\n"
+ "vector_R3___getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3\n"
"vector_R3___getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3\n"
""},
{ "vector_R3___setitem__", _wrap_vector_R3___setitem__, METH_VARARGS, "\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_R3___setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)\n"
""},
{ "vector_R3_pop", _wrap_vector_R3_pop, METH_O, "vector_R3_pop(vector_R3 self) -> R3"},
@@ -28426,6 +28485,7 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3_swiginit", vector_R3_swiginit, METH_VARARGS, NULL},
{ "generateZValues", _wrap_generateZValues, METH_VARARGS, "generateZValues(int n_points, double z_min, double z_max) -> vdouble1d_t"},
{ "materialProfileSLD", _wrap_materialProfileSLD, METH_VARARGS, "materialProfileSLD(MultiLayer const & sample, int n_points, double z_min, double z_max) -> vector_complex_t"},
+ { "magnetizationProfile", _wrap_magnetizationProfile, METH_VARARGS, "magnetizationProfile(MultiLayer const & sample, std::string component, int n_points, double z_min, double z_max) -> vdouble1d_t"},
{ "defaultMaterialProfileLimits", _wrap_defaultMaterialProfileLimits, METH_O, "defaultMaterialProfileLimits(MultiLayer const & sample) -> pvacuum_double_t"},
{ NULL, NULL, 0, NULL }
};
diff --git a/auto/Wrap/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index 373fba1a4f5..0d6bc8c80fc 100644
--- a/auto/Wrap/libBornAgainSample.py
+++ b/auto/Wrap/libBornAgainSample.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainSample.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainSample.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainSample.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainSample.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainSample.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainSample.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainSample.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainSample.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainSample.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainSample.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainSample.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainSample.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainSample.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainSample.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainSample.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainSample.vector_pvacuum_double_t___setitem__(self, *args)
@@ -1907,21 +1907,21 @@ class vector_R3(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
- __delitem__(vector_R3 self, PySliceObject * slice)
+ __delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
+ __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3
__getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
"""
return _libBornAgainSample.vector_R3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
- __setitem__(vector_R3 self, PySliceObject * slice)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
"""
return _libBornAgainSample.vector_R3___setitem__(self, *args)
@@ -2074,21 +2074,21 @@ class swig_dummy_type_const_inode_vector(object):
def __delitem__(self, *args):
r"""
__delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)
- __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSample.swig_dummy_type_const_inode_vector___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
__getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode
"""
return _libBornAgainSample.swig_dummy_type_const_inode_vector___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
__setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)
"""
return _libBornAgainSample.swig_dummy_type_const_inode_vector___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainSample_wrap.cpp b/auto/Wrap/libBornAgainSample_wrap.cpp
index 19346127733..f98d01d50ba 100644
--- a/auto/Wrap/libBornAgainSample_wrap.cpp
+++ b/auto/Wrap/libBornAgainSample_wrap.cpp
@@ -3705,9 +3705,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5520,46 +5520,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5656,46 +5656,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5793,46 +5793,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5894,46 +5894,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6015,46 +6015,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6099,7 +6099,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6167,46 +6167,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6491,46 +6491,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7020,46 +7020,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7163,46 +7163,46 @@ SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delslice__(std::vector< V
SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< Vec3< double > > *self,std::vector< Vec3< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7272,46 +7272,46 @@ SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delslice__(std::vector< I
SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_0(std::vector< INode const * > *self,std::vector< INode const * >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -9143,7 +9143,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -9156,9 +9156,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -9177,7 +9177,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -9191,9 +9191,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -9225,7 +9225,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -9237,9 +9237,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -9258,7 +9258,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -9270,9 +9270,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -9328,7 +9328,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -9406,7 +9406,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -9516,8 +9516,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10967,7 +10967,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10980,9 +10980,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -11001,7 +11001,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -11015,9 +11015,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -11049,7 +11049,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -11061,9 +11061,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -11082,7 +11082,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -11094,9 +11094,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -11152,7 +11152,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -11230,7 +11230,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -11343,8 +11343,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -12821,7 +12821,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -12834,9 +12834,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -12855,7 +12855,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12869,9 +12869,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12903,7 +12903,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12915,9 +12915,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12936,7 +12936,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12948,9 +12948,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -13006,7 +13006,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -13084,7 +13084,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -13194,8 +13194,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -14645,7 +14645,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -14658,9 +14658,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -14679,7 +14679,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14693,9 +14693,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -14727,7 +14727,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14739,9 +14739,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -14760,7 +14760,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14772,9 +14772,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -14830,7 +14830,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14908,7 +14908,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -15021,8 +15021,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -16499,7 +16499,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -16512,9 +16512,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -16533,7 +16533,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16547,9 +16547,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -16581,7 +16581,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16593,9 +16593,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -16614,7 +16614,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16626,9 +16626,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -16684,7 +16684,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -16762,7 +16762,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16872,8 +16872,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -18323,7 +18323,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -18336,9 +18336,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -18357,7 +18357,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -18371,9 +18371,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -18405,7 +18405,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -18417,9 +18417,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -18438,7 +18438,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -18450,9 +18450,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -18508,7 +18508,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -18586,7 +18586,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -18696,8 +18696,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -20147,7 +20147,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -20160,9 +20160,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -20181,7 +20181,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -20195,9 +20195,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -20229,7 +20229,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -20241,9 +20241,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -20262,7 +20262,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -20274,9 +20274,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -20332,7 +20332,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -20410,7 +20410,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -20523,8 +20523,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -23463,7 +23463,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -23476,9 +23476,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -23497,7 +23497,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23511,9 +23511,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -23545,7 +23545,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23557,9 +23557,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -23578,7 +23578,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23590,9 +23590,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -23648,7 +23648,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -23726,7 +23726,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -23839,8 +23839,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -26699,7 +26699,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *result = 0 ;
@@ -26712,9 +26712,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -26733,7 +26733,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26747,9 +26747,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *ptr = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)0;
@@ -26781,7 +26781,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26793,9 +26793,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -26814,7 +26814,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26826,9 +26826,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -26884,7 +26884,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< Vec3< double > >::__delitem__(std::vector< Vec3< double > >::difference_type)\n"
- " std::vector< Vec3< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< Vec3< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -26962,7 +26962,7 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__getitem__(std::vector< Vec3< double > >::difference_type) const\n");
return 0;
}
@@ -27071,8 +27071,8 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__setitem__(std::vector< Vec3< double > >::difference_type,std::vector< Vec3< double > >::value_type const &)\n");
return 0;
}
@@ -28521,7 +28521,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< INode const *,std::allocator< INode const * > > *result = 0 ;
@@ -28534,9 +28534,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< INode const *,std::allocator< INode const * > > *)std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(arg1,arg2);
@@ -28555,7 +28555,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< INode const *,std::allocator< INode const * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28569,9 +28569,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< INode const*,std::allocator< INode const * > > *ptr = (std::vector< INode const*,std::allocator< INode const * > > *)0;
@@ -28603,7 +28603,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28615,9 +28615,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(arg1,arg2);
@@ -28636,7 +28636,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28648,9 +28648,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(arg1,arg2);
@@ -28706,7 +28706,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< INode const * >::__delitem__(std::vector< INode const * >::difference_type)\n"
- " std::vector< INode const * >::__delitem__(PySliceObject *)\n");
+ " std::vector< INode const * >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -28783,7 +28783,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__getitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__getitem__(std::vector< INode const * >::difference_type)\n");
return 0;
}
@@ -28890,8 +28890,8 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__setitem__(std::vector< INode const * >::difference_type,std::vector< INode const * >::value_type)\n");
return 0;
}
@@ -57135,15 +57135,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -57197,15 +57197,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -57259,15 +57259,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -57321,15 +57321,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -57383,15 +57383,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -57445,15 +57445,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -57507,15 +57507,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -57625,15 +57625,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
@@ -57743,15 +57743,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3___delslice__", _wrap_vector_R3___delslice__, METH_VARARGS, "vector_R3___delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"},
{ "vector_R3___delitem__", _wrap_vector_R3___delitem__, METH_VARARGS, "\n"
"vector_R3___delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)\n"
- "vector_R3___delitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_R3___getitem__", _wrap_vector_R3___getitem__, METH_VARARGS, "\n"
- "vector_R3___getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3\n"
+ "vector_R3___getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3\n"
"vector_R3___getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3\n"
""},
{ "vector_R3___setitem__", _wrap_vector_R3___setitem__, METH_VARARGS, "\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_R3___setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)\n"
""},
{ "vector_R3_pop", _wrap_vector_R3_pop, METH_O, "vector_R3_pop(vector_R3 self) -> R3"},
@@ -57805,15 +57805,15 @@ static PyMethodDef SwigMethods[] = {
{ "swig_dummy_type_const_inode_vector___delslice__", _wrap_swig_dummy_type_const_inode_vector___delslice__, METH_VARARGS, "swig_dummy_type_const_inode_vector___delslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)"},
{ "swig_dummy_type_const_inode_vector___delitem__", _wrap_swig_dummy_type_const_inode_vector___delitem__, METH_VARARGS, "\n"
"swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)\n"
- "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "swig_dummy_type_const_inode_vector___getitem__", _wrap_swig_dummy_type_const_inode_vector___getitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector\n"
+ "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector\n"
"swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode\n"
""},
{ "swig_dummy_type_const_inode_vector___setitem__", _wrap_swig_dummy_type_const_inode_vector___setitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
"swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)\n"
""},
{ "swig_dummy_type_const_inode_vector_pop", _wrap_swig_dummy_type_const_inode_vector_pop, METH_O, "swig_dummy_type_const_inode_vector_pop(swig_dummy_type_const_inode_vector self) -> INode"},
diff --git a/auto/Wrap/libBornAgainSim.py b/auto/Wrap/libBornAgainSim.py
index 0ed39a6320f..9bf1d294d65 100644
--- a/auto/Wrap/libBornAgainSim.py
+++ b/auto/Wrap/libBornAgainSim.py
@@ -195,21 +195,21 @@ class vdouble1d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble1d_t self, std::vector< double >::difference_type i)
- __delitem__(vdouble1d_t self, PySliceObject * slice)
+ __delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
__getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
"""
return _libBornAgainSim.vdouble1d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, PySliceObject * slice)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
"""
return _libBornAgainSim.vdouble1d_t___setitem__(self, *args)
@@ -361,21 +361,21 @@ class vdouble2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)
- __delitem__(vdouble2d_t self, PySliceObject * slice)
+ __delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
__getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t
"""
return _libBornAgainSim.vdouble2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, PySliceObject * slice)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)
"""
return _libBornAgainSim.vdouble2d_t___setitem__(self, *args)
@@ -527,21 +527,21 @@ class vector_integer_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_integer_t self, std::vector< int >::difference_type i)
- __delitem__(vector_integer_t self, PySliceObject * slice)
+ __delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
__getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
"""
return _libBornAgainSim.vector_integer_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, PySliceObject * slice)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
"""
return _libBornAgainSim.vector_integer_t___setitem__(self, *args)
@@ -693,21 +693,21 @@ class vinteger2d_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)
- __delitem__(vinteger2d_t self, PySliceObject * slice)
+ __delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
__getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t
"""
return _libBornAgainSim.vinteger2d_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, PySliceObject * slice)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)
"""
return _libBornAgainSim.vinteger2d_t___setitem__(self, *args)
@@ -859,21 +859,21 @@ class vector_longinteger_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)
- __delitem__(vector_longinteger_t self, PySliceObject * slice)
+ __delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
__getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &
"""
return _libBornAgainSim.vector_longinteger_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, PySliceObject * slice)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)
"""
return _libBornAgainSim.vector_longinteger_t___setitem__(self, *args)
@@ -1025,21 +1025,21 @@ class vector_complex_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)
- __delitem__(vector_complex_t self, PySliceObject * slice)
+ __delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
__getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &
"""
return _libBornAgainSim.vector_complex_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, PySliceObject * slice)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)
"""
return _libBornAgainSim.vector_complex_t___setitem__(self, *args)
@@ -1191,21 +1191,21 @@ class vector_string_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_string_t self, std::vector< std::string >::difference_type i)
- __delitem__(vector_string_t self, PySliceObject * slice)
+ __delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t
+ __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
__getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
"""
return _libBornAgainSim.vector_string_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
- __setitem__(vector_string_t self, PySliceObject * slice)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
+ __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
"""
return _libBornAgainSim.vector_string_t___setitem__(self, *args)
@@ -1540,21 +1540,21 @@ class vector_pvacuum_double_t(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)
- __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
__getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t
"""
return _libBornAgainSim.vector_pvacuum_double_t___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, PySliceObject * slice)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
+ __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)
"""
return _libBornAgainSim.vector_pvacuum_double_t___setitem__(self, *args)
@@ -1924,21 +1924,21 @@ class vector_R3(object):
def __delitem__(self, *args):
r"""
__delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)
- __delitem__(vector_R3 self, PySliceObject * slice)
+ __delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3
+ __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3
__getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3
"""
return _libBornAgainSim.vector_R3___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
- __setitem__(vector_R3 self, PySliceObject * slice)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
+ __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
__setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)
"""
return _libBornAgainSim.vector_R3___setitem__(self, *args)
@@ -2092,21 +2092,21 @@ class swig_dummy_type_const_inode_vector(object):
def __delitem__(self, *args):
r"""
__delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)
- __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
"""
return _libBornAgainSim.swig_dummy_type_const_inode_vector___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
__getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode
"""
return _libBornAgainSim.swig_dummy_type_const_inode_vector___getitem__(self, *args)
def __setitem__(self, *args):
r"""
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)
- __setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)
+ __setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)
__setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)
"""
return _libBornAgainSim.swig_dummy_type_const_inode_vector___setitem__(self, *args)
diff --git a/auto/Wrap/libBornAgainSim_wrap.cpp b/auto/Wrap/libBornAgainSim_wrap.cpp
index 3bc782622b1..90e01b509dd 100644
--- a/auto/Wrap/libBornAgainSim_wrap.cpp
+++ b/auto/Wrap/libBornAgainSim_wrap.cpp
@@ -3635,9 +3635,9 @@ namespace swig {
#include <iostream>
#if PY_VERSION_HEX >= 0x03020000
-# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
+# define SWIGPY_SLICEOBJECT PyObject
#else
-# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
+# define SWIGPY_SLICEOBJECT PySliceObject
#endif
@@ -5450,46 +5450,46 @@ SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *sel
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< double,std::allocator< double > >::difference_type id = i;
std::vector< double,std::allocator< double > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5586,46 +5586,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vec
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5723,46 +5723,46 @@ SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std:
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
swig::erase(self, 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){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< int,std::allocator< int > >::difference_type id = i;
std::vector< int,std::allocator< int > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5824,46 +5824,46 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -5945,46 +5945,46 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< uns
SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6029,7 +6029,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_ (PyObject *o, std::complex<double>* val)
SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
const std::complex<double>&
@@ -6097,46 +6097,46 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::ve
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6421,46 +6421,46 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::stri
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -6950,46 +6950,46 @@ SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delslice__(
SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< double,double > > *self,std::vector< std::pair< double,double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,PySliceObject *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< double,double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type id = i;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7096,46 +7096,46 @@ SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delslice__(std::vector< V
SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< Vec3< double > > *self,std::vector< Vec3< double > >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN std::vector< Vec3< double >,std::allocator< Vec3< double > > > *std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,PySliceObject *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type id = i;
std::vector< Vec3< double >,std::allocator< Vec3< double > > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -7205,46 +7205,46 @@ SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delslice__(std::vector< I
SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_0(std::vector< INode const * > *self,std::vector< INode const * >::difference_type i){
swig::erase(self, swig::getpos(self, i));
}
-SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN std::vector< INode const *,std::allocator< INode const * > > *std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
return swig::getslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,PySliceObject *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice,std::vector< INode const *,std::allocator< INode const * > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::setslice(self, id, jd, step, v);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
}
-SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,SWIGPY_SLICEOBJECT *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
std::vector< INode const*,std::allocator< INode const * > >::difference_type id = i;
std::vector< INode const*,std::allocator< INode const * > >::difference_type jd = j;
swig::delslice(self, id, jd, step);
@@ -8652,7 +8652,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< double,std::allocator< double > > *result = 0 ;
@@ -8665,9 +8665,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
@@ -8686,7 +8686,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< double,std::allocator< double > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8700,9 +8700,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
@@ -8734,7 +8734,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8746,9 +8746,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
@@ -8767,7 +8767,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< double > *arg1 = (std::vector< double > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -8779,9 +8779,9 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< double > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
@@ -8837,7 +8837,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
- " std::vector< double >::__delitem__(PySliceObject *)\n");
+ " std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -8915,7 +8915,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__getitem__(PySliceObject *)\n"
+ " std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
return 0;
}
@@ -9025,8 +9025,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble1d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(PySliceObject *)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
return 0;
}
@@ -10476,7 +10476,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
@@ -10489,9 +10489,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -10510,7 +10510,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10524,9 +10524,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
@@ -10558,7 +10558,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10570,9 +10570,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -10591,7 +10591,7 @@ fail:
SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -10603,9 +10603,9 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_1(PyObject *self, Py_ss
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -10661,7 +10661,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
- " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -10739,7 +10739,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
return 0;
}
@@ -10852,8 +10852,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vdouble2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
- " std::vector< std::vector< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+ " std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
return 0;
}
@@ -12330,7 +12330,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< int,std::allocator< int > > *result = 0 ;
@@ -12343,9 +12343,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
@@ -12364,7 +12364,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< int,std::allocator< int > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12378,9 +12378,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
@@ -12412,7 +12412,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12424,9 +12424,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
@@ -12445,7 +12445,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< int > *arg1 = (std::vector< int > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -12457,9 +12457,9 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< int > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
@@ -12515,7 +12515,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
- " std::vector< int >::__delitem__(PySliceObject *)\n");
+ " std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -12593,7 +12593,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__getitem__(PySliceObject *)\n"
+ " std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
return 0;
}
@@ -12703,8 +12703,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_integer_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(PySliceObject *)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
return 0;
}
@@ -14154,7 +14154,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
@@ -14167,9 +14167,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -14188,7 +14188,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14202,9 +14202,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_0(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
@@ -14236,7 +14236,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14248,9 +14248,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -14269,7 +14269,7 @@ fail:
SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -14281,9 +14281,9 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___delitem____SWIG_1(PyObject *self, Py_s
arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -14339,7 +14339,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
- " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -14417,7 +14417,7 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___getitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
return 0;
}
@@ -14530,8 +14530,8 @@ SWIGINTERN PyObject *_wrap_vinteger2d_t___setitem__(PyObject *self, PyObject *ar
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vinteger2d_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
- " std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
+ " std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
return 0;
}
@@ -16008,7 +16008,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;
@@ -16021,9 +16021,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< unsigned long,std::allocator< unsigned long > > *)std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(arg1,arg2);
@@ -16042,7 +16042,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< unsigned long,std::allocator< unsigned long > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16056,9 +16056,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
@@ -16090,7 +16090,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16102,9 +16102,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(arg1,arg2);
@@ -16123,7 +16123,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -16135,9 +16135,9 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_1(PyObject *se
arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(arg1,arg2);
@@ -16193,7 +16193,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< unsigned long >::__delitem__(std::vector< unsigned long >::difference_type)\n"
- " std::vector< unsigned long >::__delitem__(PySliceObject *)\n");
+ " std::vector< unsigned long >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -16271,7 +16271,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__getitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__getitem__(std::vector< unsigned long >::difference_type) const\n");
return 0;
}
@@ -16381,8 +16381,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
- " std::vector< unsigned long >::__setitem__(PySliceObject *)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< unsigned long >::__setitem__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::value_type const &)\n");
return 0;
}
@@ -17832,7 +17832,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
@@ -17845,9 +17845,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -17866,7 +17866,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17880,9 +17880,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
@@ -17914,7 +17914,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17926,9 +17926,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -17947,7 +17947,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -17959,9 +17959,9 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_1(PyObject *self,
arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -18017,7 +18017,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
- " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::complex< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -18095,7 +18095,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
return 0;
}
@@ -18205,8 +18205,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_complex_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
- " std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+ " std::vector< std::complex< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
return 0;
}
@@ -19656,7 +19656,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
@@ -19669,9 +19669,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
@@ -19690,7 +19690,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19704,9 +19704,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
@@ -19738,7 +19738,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19750,9 +19750,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
@@ -19771,7 +19771,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -19783,9 +19783,9 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_1(PyObject *self, P
arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
@@ -19841,7 +19841,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
- " std::vector< std::string >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -19919,7 +19919,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
return 0;
}
@@ -20032,8 +20032,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_string_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
- " std::vector< std::string >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
return 0;
}
@@ -22972,7 +22972,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *result = 0 ;
@@ -22985,9 +22985,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -23006,7 +23006,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23020,9 +23020,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_0(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *)0;
@@ -23054,7 +23054,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23066,9 +23066,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -23087,7 +23087,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< std::pair< double,double > > *arg1 = (std::vector< std::pair< double,double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -23099,9 +23099,9 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___delitem____SWIG_1(PyObject
arg1 = reinterpret_cast< std::vector< std::pair< double,double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_std_pair_Sl_double_Sc_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -23157,7 +23157,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< std::pair< double,double > >::__delitem__(std::vector< std::pair< double,double > >::difference_type)\n"
- " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -23235,7 +23235,7 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___getitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__getitem__(std::vector< std::pair< double,double > >::difference_type) const\n");
return 0;
}
@@ -23348,8 +23348,8 @@ SWIGINTERN PyObject *_wrap_vector_pvacuum_double_t___setitem__(PyObject *self, P
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_pvacuum_double_t___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
- " std::vector< std::pair< double,double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)\n"
+ " std::vector< std::pair< double,double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< std::pair< double,double > >::__setitem__(std::vector< std::pair< double,double > >::difference_type,std::vector< std::pair< double,double > >::value_type const &)\n");
return 0;
}
@@ -26332,7 +26332,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *result = 0 ;
@@ -26345,9 +26345,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)std_vector_Sl_Vec3_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
@@ -26366,7 +26366,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26380,9 +26380,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_0(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< Vec3< double >,std::allocator< Vec3< double > > > *ptr = (std::vector< Vec3< double >,std::allocator< Vec3< double > > > *)0;
@@ -26414,7 +26414,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26426,9 +26426,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
@@ -26447,7 +26447,7 @@ fail:
SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< Vec3< double > > *arg1 = (std::vector< Vec3< double > > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -26459,9 +26459,9 @@ SWIGINTERN PyObject *_wrap_vector_R3___delitem____SWIG_1(PyObject *self, Py_ssiz
arg1 = reinterpret_cast< std::vector< Vec3< double > > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
@@ -26517,7 +26517,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< Vec3< double > >::__delitem__(std::vector< Vec3< double > >::difference_type)\n"
- " std::vector< Vec3< double > >::__delitem__(PySliceObject *)\n");
+ " std::vector< Vec3< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -26595,7 +26595,7 @@ SWIGINTERN PyObject *_wrap_vector_R3___getitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__getitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__getitem__(std::vector< Vec3< double > >::difference_type) const\n");
return 0;
}
@@ -26704,8 +26704,8 @@ SWIGINTERN PyObject *_wrap_vector_R3___setitem__(PyObject *self, PyObject *args)
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_R3___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
- " std::vector< Vec3< double > >::__setitem__(PySliceObject *)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
+ " std::vector< Vec3< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< Vec3< double > >::__setitem__(std::vector< Vec3< double > >::difference_type,std::vector< Vec3< double > >::value_type const &)\n");
return 0;
}
@@ -28154,7 +28154,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
std::vector< INode const *,std::allocator< INode const * > > *result = 0 ;
@@ -28167,9 +28167,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
result = (std::vector< INode const *,std::allocator< INode const * > > *)std_vector_Sl_INode_SS_const_Sm__Sg____getitem____SWIG_0(arg1,arg2);
@@ -28188,7 +28188,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
std::vector< INode const *,std::allocator< INode const * > > *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28202,9 +28202,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
{
std::vector< INode const*,std::allocator< INode const * > > *ptr = (std::vector< INode const*,std::allocator< INode const * > > *)0;
@@ -28236,7 +28236,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28248,9 +28248,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(arg1,arg2);
@@ -28269,7 +28269,7 @@ fail:
SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
std::vector< INode const * > *arg1 = (std::vector< INode const * > *) 0 ;
- PySliceObject *arg2 = (PySliceObject *) 0 ;
+ SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
@@ -28281,9 +28281,9 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___delitem____SWIG_
arg1 = reinterpret_cast< std::vector< INode const * > * >(argp1);
{
if (!PySlice_Check(swig_obj[1])) {
- SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
}
- arg2 = (PySliceObject *) swig_obj[1];
+ arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
}
try {
std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(arg1,arg2);
@@ -28339,7 +28339,7 @@ fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___delitem__'.\n"
" Possible C/C++ prototypes are:\n"
" std::vector< INode const * >::__delitem__(std::vector< INode const * >::difference_type)\n"
- " std::vector< INode const * >::__delitem__(PySliceObject *)\n");
+ " std::vector< INode const * >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
return 0;
}
@@ -28416,7 +28416,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___getitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___getitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__getitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__getitem__(std::vector< INode const * >::difference_type)\n");
return 0;
}
@@ -28523,8 +28523,8 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_inode_vector___setitem__(PyObje
fail:
SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_inode_vector___setitem__'.\n"
" Possible C/C++ prototypes are:\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
- " std::vector< INode const * >::__setitem__(PySliceObject *)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
+ " std::vector< INode const * >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
" std::vector< INode const * >::__setitem__(std::vector< INode const * >::difference_type,std::vector< INode const * >::value_type)\n");
return 0;
}
@@ -35500,15 +35500,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, "vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
{ "vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, "\n"
"vdouble1d_t___delitem__(vdouble1d_t self, std::vector< double >::difference_type i)\n"
- "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
"vdouble1d_t___getitem__(vdouble1d_t self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &\n"
""},
{ "vdouble1d_t___setitem__", _wrap_vdouble1d_t___setitem__, METH_VARARGS, "\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, PySliceObject * slice)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
+ "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
""},
{ "vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_O, "vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
@@ -35562,15 +35562,15 @@ static PyMethodDef SwigMethods[] = {
{ "vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, "vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
{ "vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, "\n"
"vdouble2d_t___delitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i)\n"
- "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
"vdouble2d_t___getitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i) -> vdouble1d_t\n"
""},
{ "vdouble2d_t___setitem__", _wrap_vdouble2d_t___setitem__, METH_VARARGS, "\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, PySliceObject * slice)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
+ "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
""},
{ "vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_O, "vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
@@ -35624,15 +35624,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, "vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
{ "vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, "\n"
"vector_integer_t___delitem__(vector_integer_t self, std::vector< int >::difference_type i)\n"
- "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
"vector_integer_t___getitem__(vector_integer_t self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &\n"
""},
{ "vector_integer_t___setitem__", _wrap_vector_integer_t___setitem__, METH_VARARGS, "\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)\n"
- "vector_integer_t___setitem__(vector_integer_t self, PySliceObject * slice)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)\n"
+ "vector_integer_t___setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
""},
{ "vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_O, "vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
@@ -35686,15 +35686,15 @@ static PyMethodDef SwigMethods[] = {
{ "vinteger2d_t___delslice__", _wrap_vinteger2d_t___delslice__, METH_VARARGS, "vinteger2d_t___delslice__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)"},
{ "vinteger2d_t___delitem__", _wrap_vinteger2d_t___delitem__, METH_VARARGS, "\n"
"vinteger2d_t___delitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i)\n"
- "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
"vinteger2d_t___getitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i) -> vector_integer_t\n"
""},
{ "vinteger2d_t___setitem__", _wrap_vinteger2d_t___setitem__, METH_VARARGS, "\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, PySliceObject * slice)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
+ "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vinteger2d_t___setitem__(vinteger2d_t self, std::vector< std::vector< int > >::difference_type i, vector_integer_t x)\n"
""},
{ "vinteger2d_t_pop", _wrap_vinteger2d_t_pop, METH_O, "vinteger2d_t_pop(vinteger2d_t self) -> vector_integer_t"},
@@ -35748,15 +35748,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, "vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
{ "vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, "\n"
"vector_longinteger_t___delitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i)\n"
- "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
"vector_longinteger_t___getitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i) -> std::vector< unsigned long >::value_type const &\n"
""},
{ "vector_longinteger_t___setitem__", _wrap_vector_longinteger_t___setitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)\n"
- "vector_longinteger_t___setitem__(vector_longinteger_t self, PySliceObject * slice)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)\n"
+ "vector_longinteger_t___setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
""},
{ "vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_O, "vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
@@ -35810,15 +35810,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, "vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
{ "vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, "\n"
"vector_complex_t___delitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i)\n"
- "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
"vector_complex_t___getitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i) -> std::vector< std::complex< double > >::value_type const &\n"
""},
{ "vector_complex_t___setitem__", _wrap_vector_complex_t___setitem__, METH_VARARGS, "\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)\n"
- "vector_complex_t___setitem__(vector_complex_t self, PySliceObject * slice)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)\n"
+ "vector_complex_t___setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
""},
{ "vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_O, "vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
@@ -35872,15 +35872,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, "vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
{ "vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, "\n"
"vector_string_t___delitem__(vector_string_t self, std::vector< std::string >::difference_type i)\n"
- "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, PySliceObject * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
"vector_string_t___getitem__(vector_string_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &\n"
""},
{ "vector_string_t___setitem__", _wrap_vector_string_t___setitem__, METH_VARARGS, "\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)\n"
- "vector_string_t___setitem__(vector_string_t self, PySliceObject * slice)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice, vector_string_t v)\n"
+ "vector_string_t___setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
""},
{ "vector_string_t_pop", _wrap_vector_string_t_pop, METH_O, "vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
@@ -35990,15 +35990,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_pvacuum_double_t___delslice__", _wrap_vector_pvacuum_double_t___delslice__, METH_VARARGS, "vector_pvacuum_double_t___delslice__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, std::vector< std::pair< double,double > >::difference_type j)"},
{ "vector_pvacuum_double_t___delitem__", _wrap_vector_pvacuum_double_t___delitem__, METH_VARARGS, "\n"
"vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i)\n"
- "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_pvacuum_double_t___getitem__", _wrap_vector_pvacuum_double_t___getitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, PySliceObject * slice) -> vector_pvacuum_double_t\n"
+ "vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\n"
"vector_pvacuum_double_t___getitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i) -> pvacuum_double_t\n"
""},
{ "vector_pvacuum_double_t___setitem__", _wrap_vector_pvacuum_double_t___setitem__, METH_VARARGS, "\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice, vector_pvacuum_double_t v)\n"
- "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, PySliceObject * slice)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)\n"
+ "vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_pvacuum_double_t___setitem__(vector_pvacuum_double_t self, std::vector< std::pair< double,double > >::difference_type i, pvacuum_double_t x)\n"
""},
{ "vector_pvacuum_double_t_pop", _wrap_vector_pvacuum_double_t_pop, METH_O, "vector_pvacuum_double_t_pop(vector_pvacuum_double_t self) -> pvacuum_double_t"},
@@ -36112,15 +36112,15 @@ static PyMethodDef SwigMethods[] = {
{ "vector_R3___delslice__", _wrap_vector_R3___delslice__, METH_VARARGS, "vector_R3___delslice__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, std::vector< Vec3< double > >::difference_type j)"},
{ "vector_R3___delitem__", _wrap_vector_R3___delitem__, METH_VARARGS, "\n"
"vector_R3___delitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i)\n"
- "vector_R3___delitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___delitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "vector_R3___getitem__", _wrap_vector_R3___getitem__, METH_VARARGS, "\n"
- "vector_R3___getitem__(vector_R3 self, PySliceObject * slice) -> vector_R3\n"
+ "vector_R3___getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3\n"
"vector_R3___getitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i) -> R3\n"
""},
{ "vector_R3___setitem__", _wrap_vector_R3___setitem__, METH_VARARGS, "\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)\n"
- "vector_R3___setitem__(vector_R3 self, PySliceObject * slice)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice, vector_R3 v)\n"
+ "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\n"
"vector_R3___setitem__(vector_R3 self, std::vector< Vec3< double > >::difference_type i, R3 x)\n"
""},
{ "vector_R3_pop", _wrap_vector_R3_pop, METH_O, "vector_R3_pop(vector_R3 self) -> R3"},
@@ -36174,15 +36174,15 @@ static PyMethodDef SwigMethods[] = {
{ "swig_dummy_type_const_inode_vector___delslice__", _wrap_swig_dummy_type_const_inode_vector___delslice__, METH_VARARGS, "swig_dummy_type_const_inode_vector___delslice__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, std::vector< INode const * >::difference_type j)"},
{ "swig_dummy_type_const_inode_vector___delitem__", _wrap_swig_dummy_type_const_inode_vector___delitem__, METH_VARARGS, "\n"
"swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i)\n"
- "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
""},
{ "swig_dummy_type_const_inode_vector___getitem__", _wrap_swig_dummy_type_const_inode_vector___getitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice) -> swig_dummy_type_const_inode_vector\n"
+ "swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector\n"
"swig_dummy_type_const_inode_vector___getitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i) -> INode\n"
""},
{ "swig_dummy_type_const_inode_vector___setitem__", _wrap_swig_dummy_type_const_inode_vector___setitem__, METH_VARARGS, "\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice, swig_dummy_type_const_inode_vector v)\n"
- "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, PySliceObject * slice)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice, swig_dummy_type_const_inode_vector v)\n"
+ "swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, SWIGPY_SLICEOBJECT * slice)\n"
"swig_dummy_type_const_inode_vector___setitem__(swig_dummy_type_const_inode_vector self, std::vector< INode const * >::difference_type i, INode x)\n"
""},
{ "swig_dummy_type_const_inode_vector_pop", _wrap_swig_dummy_type_const_inode_vector_pop, METH_O, "swig_dummy_type_const_inode_vector_pop(swig_dummy_type_const_inode_vector self) -> INode"},
--
GitLab