From 24785abb46ac4b05949ab703bac2ac2c9db0e51a Mon Sep 17 00:00:00 2001
From: Joachim Wuttke <j.wuttke@fz-juelich.de>
Date: Fri, 7 Jul 2023 19:57:16 +0200
Subject: [PATCH] py plots in degrees again
---
Base/Axis/Frame.cpp | 8 +
Base/Axis/Frame.h | 2 +
Base/Axis/Scale.cpp | 32 ++
Base/Axis/Scale.h | 4 +
Device/Data/Datafield.cpp | 18 +-
Device/Data/Datafield.h | 25 +-
Wrap/Python/ba_plot.py | 42 +-
auto/Wrap/libBornAgainBase.py | 12 +
auto/Wrap/libBornAgainBase_wrap.cpp | 72 ++++
auto/Wrap/libBornAgainDevice.py | 28 +-
auto/Wrap/libBornAgainDevice_wrap.cpp | 194 +++++----
auto/Wrap/libBornAgainFit.py | 64 +--
auto/Wrap/libBornAgainFit_wrap.cpp | 454 ++++++++++-----------
auto/Wrap/libBornAgainParam.py | 80 ++--
auto/Wrap/libBornAgainParam_wrap.cpp | 566 +++++++++++++-------------
auto/Wrap/libBornAgainSample.py | 80 ++--
auto/Wrap/libBornAgainSample_wrap.cpp | 566 +++++++++++++-------------
17 files changed, 1208 insertions(+), 1039 deletions(-)
diff --git a/Base/Axis/Frame.cpp b/Base/Axis/Frame.cpp
index 13d6a0ea95a..e7d7c2f386e 100644
--- a/Base/Axis/Frame.cpp
+++ b/Base/Axis/Frame.cpp
@@ -138,3 +138,11 @@ bool Frame::hasSameSizes(const Frame& o) const
return false;
return true;
}
+
+Frame* Frame::plottableFrame() const
+{
+ std::vector<const Scale*> outaxes;
+ for (const Scale* s : m_axes)
+ outaxes.emplace_back(new Scale(s->plottableScale()));
+ return new Frame(std::move(outaxes));
+}
diff --git a/Base/Axis/Frame.h b/Base/Axis/Frame.h
index 8bf1554d06f..33e016a5653 100644
--- a/Base/Axis/Frame.h
+++ b/Base/Axis/Frame.h
@@ -81,6 +81,8 @@ public:
std::vector<const Scale*> clonedAxes() const;
#endif // SWIG
+ Frame* plottableFrame() const;
+
protected:
OwningVector<const Scale> m_axes;
diff --git a/Base/Axis/Scale.cpp b/Base/Axis/Scale.cpp
index faf84df19ad..9e927f3c154 100644
--- a/Base/Axis/Scale.cpp
+++ b/Base/Axis/Scale.cpp
@@ -15,6 +15,9 @@
#include "Base/Axis/Scale.h"
#include "Base/Util/Assert.h"
#include <iomanip>
+#include <iostream>
+#include <numbers>
+using std::numbers::pi;
Scale::Scale(std::string name, const std::vector<Bin1D>& bins)
: m_name(name)
@@ -158,3 +161,32 @@ std::ostream& operator<<(std::ostream& ostr, const Scale& ax)
ostr << "])";
return ostr;
}
+
+std::string Scale::unit() const
+{
+ if (m_name.empty())
+ return "";
+ size_t i = m_name.size() - 1;
+ if (m_name[i] != ')')
+ return "";
+ for (size_t j = i - 1; j > 0; --j)
+ if (m_name[j] == '(')
+ return m_name.substr(j + 1, i - j - 1);
+ return "";
+}
+
+Scale Scale::plottableScale() const
+{
+ std::string u = unit();
+ if (u == "rad") {
+ std::string outname = m_name.substr(0, m_name.size() - u.size() - 2) + "(deg)";
+ std::vector<Bin1D> outvector;
+ for (const Bin1D b : m_bins) {
+ double bmi = b.lowerBound() * 180 / pi;
+ double bma = b.upperBound() * 180 / pi;
+ outvector.emplace_back(Bin1D::FromTo(bmi, bma));
+ }
+ return Scale(outname, outvector);
+ }
+ return *this;
+}
diff --git a/Base/Axis/Scale.h b/Base/Axis/Scale.h
index 69d16cf70f6..ccd0feba876 100644
--- a/Base/Axis/Scale.h
+++ b/Base/Axis/Scale.h
@@ -76,6 +76,10 @@ public:
friend std::ostream& operator<<(std::ostream& ostr, const Scale& m);
+ std::string unit() const;
+
+ Scale plottableScale() const;
+
protected:
// private:
std::string m_name;
diff --git a/Device/Data/Datafield.cpp b/Device/Data/Datafield.cpp
index 14dda90a8b3..17de3fcb83b 100644
--- a/Device/Data/Datafield.cpp
+++ b/Device/Data/Datafield.cpp
@@ -52,6 +52,16 @@ Datafield* Datafield::clone() const
return data;
}
+void Datafield::setTitle(const std::string& title)
+{
+ m_title = title;
+}
+
+std::string Datafield::title()
+{
+ return m_title;
+}
+
double& Datafield::operator[](size_t i)
{
return m_values[i];
@@ -312,11 +322,7 @@ Datafield* Datafield::create_yProjection(int xbinlow, int xbinup) const
return new Datafield({yAxis().clone()}, out);
}
-void Datafield::setTitle(const std::string& title)
-{
- m_title = title;
-}
-std::string Datafield::title()
+Datafield Datafield::plottableField() const
{
- return m_title;
+ return {frame().plottableFrame(), m_values, m_errSigmas};
}
diff --git a/Device/Data/Datafield.h b/Device/Data/Datafield.h
index 6c9f37109ef..2f54635c39a 100644
--- a/Device/Data/Datafield.h
+++ b/Device/Data/Datafield.h
@@ -46,12 +46,19 @@ public:
Datafield* clone() const;
- // for use from Python:
+ void setTitle(const std::string& title);
+ std::string title();
+
+ //... for use from Python:
void setAt(size_t i, double val);
double valAt(size_t i) const;
+#ifdef BORNAGAIN_PYTHON
+ //! Returns data as Python numpy array
+ PyObject* npArray() const;
+#endif
- // retrieve basic info
+ //... retrieve basic info
const Frame& frame() const;
size_t rank() const;
@@ -69,21 +76,18 @@ public:
double maxVal() const;
double minVal() const;
- // modifiers
+ //... modifiers
+
+ Datafield plottableField() const;
//! Multiplies contents by constant factor, e.g. to shift curves in log plot
void scale(double factor);
- // helpers
+ //... helpers
Datafield* crop(double xmin, double ymin, double xmax, double ymax) const;
Datafield* crop(double xmin, double xmax) const;
-#ifdef BORNAGAIN_PYTHON
- //! Returns data as Python numpy array
- PyObject* npArray() const;
-#endif
-
//! Project a 2D histogram into 1D histogram along X. The projection is made
//! from all bins along y-axis.
Datafield* xProjection() const;
@@ -114,9 +118,6 @@ public:
//! @param xup upper edje on x-axis
Datafield* yProjection(double xlow, double xup) const;
- void setTitle(const std::string& title);
- std::string title();
-
#ifndef SWIG
double& operator[](size_t i);
const double& operator[](size_t i) const;
diff --git a/Wrap/Python/ba_plot.py b/Wrap/Python/ba_plot.py
index ba1418f8428..900642d05b2 100644
--- a/Wrap/Python/ba_plot.py
+++ b/Wrap/Python/ba_plot.py
@@ -197,10 +197,11 @@ def plot_specular_curve(result):
:param result: Datafield from SpecularSimulation
Used internally.
"""
- intensity = result.npArray()
- x_axis = result.axis(0).binCenters()
+ pfield = result.plottableField()
+ intensity = pfield.npArray()
+ x_axis = pfield.axis(0).binCenters()
- xlabel = plotargs.pop('xlabel', get_axes_labels(result)[0])
+ xlabel = plotargs.pop('xlabel', get_axes_labels(pfield)[0])
ylabel = plotargs.pop('ylabel', "Intensity")
plt.yscale('log')
@@ -403,8 +404,9 @@ def plot_simres(result, **kwargs):
Used internally and in a few examples.
"""
- axes_limits = get_axes_limits(result)
- axes_labels = get_axes_labels(result)
+ pfield = result.plottableField()
+ axes_limits = get_axes_limits(pfield)
+ axes_labels = get_axes_labels(pfield)
if 'xlabel' not in kwargs:
kwargs['xlabel'] = axes_labels[0]
@@ -480,18 +482,19 @@ def make_plot(results, ncol):
if datfile:
save_results(results, datfile)
- multiPlot = MultiPlot(len(results), ncol,
+ pfields = [result.plottableField() for result in results]
+ multiPlot = MultiPlot(len(pfields), ncol,
plotargs.pop('fontsize', None))
cmap = plotargs.pop('cmap', cmap_default)
# Always the same color legend, to facilitate comparisons between figures.
norm = mpl.colors.LogNorm(1e-8, 1)
# Plot the subfigures.
- for i, result in enumerate(results):
+ for i, pfield in enumerate(pfields):
ax = multiPlot.axes[i]
- axes_limits = get_axes_limits(result)
+ axes_limits = get_axes_limits(pfield)
- im = ax.imshow(result.npArray(),
+ im = ax.imshow(pfield.npArray(),
cmap=cmap,
norm=norm,
extent=axes_limits,
@@ -503,8 +506,8 @@ def make_plot(results, ncol):
if i % ncol == 0:
ax.set_ylabel(r'$\alpha_{\rm f} (^{\circ})$',
fontsize=multiPlot.fontsize)
- if result.title() != "":
- ax.set_title(result.title(), fontsize=multiPlot.fontsize)
+ if pfield.title() != "":
+ ax.set_title(pfield.title(), fontsize=multiPlot.fontsize)
ax.tick_params(axis='both',
which='major',
labelsize=multiPlot.fontsize*21/24)
@@ -514,18 +517,18 @@ def make_plot(results, ncol):
show_or_export()
-def plot_multicurve(results, xlabel, ylabel):
+def plot_multicurve(pfields, xlabel, ylabel):
"""
Plots any number of xy curves into one frame.
"""
if datfile:
- save_results(results, datfile)
+ save_results(pfields, datfile)
legend = []
- for result in results:
- x = result.axis(0).binCenters()
- y = result.npArray()
- legend.append(result.title())
+ for pfield in pfields:
+ x = pfield.axis(0).binCenters()
+ y = pfield.npArray()
+ legend.append(pfield.title())
plt.plot(x, y)
inside_ticks()
@@ -540,8 +543,9 @@ def plot_multicurve(results, xlabel, ylabel):
def plot_multicurve_specular(results):
plt.yscale('log')
- xlabel = get_axes_labels(results[0])[0]
- plot_multicurve(results, xlabel, r'Intensity')
+ pfields = [result.plottableField() for result in results]
+ xlabel = get_axes_labels(pfields[0])[0]
+ plot_multicurve(pfields, xlabel, r'Intensity')
# ************************************************************************** #
# global settings
diff --git a/auto/Wrap/libBornAgainBase.py b/auto/Wrap/libBornAgainBase.py
index 864aeacdf19..25f1d41316b 100644
--- a/auto/Wrap/libBornAgainBase.py
+++ b/auto/Wrap/libBornAgainBase.py
@@ -1932,6 +1932,14 @@ class Scale(object):
def __eq__(self, right):
r"""__eq__(Scale self, Scale right) -> bool"""
return _libBornAgainBase.Scale___eq__(self, right)
+
+ def unit(self):
+ r"""unit(Scale self) -> std::string"""
+ return _libBornAgainBase.Scale_unit(self)
+
+ def plottableScale(self):
+ r"""plottableScale(Scale self) -> Scale"""
+ return _libBornAgainBase.Scale_plottableScale(self)
__swig_destroy__ = _libBornAgainBase.delete_Scale
# Register Scale in _libBornAgainBase:
@@ -2011,6 +2019,10 @@ class Frame(ICloneable):
r"""__eq__(Frame self, Frame arg2) -> bool"""
return _libBornAgainBase.Frame___eq__(self, arg2)
+ def plottableFrame(self):
+ r"""plottableFrame(Frame self) -> Frame"""
+ return _libBornAgainBase.Frame_plottableFrame(self)
+
# Register Frame in _libBornAgainBase:
_libBornAgainBase.Frame_swigregister(Frame)
class R3(object):
diff --git a/auto/Wrap/libBornAgainBase_wrap.cpp b/auto/Wrap/libBornAgainBase_wrap.cpp
index f2f936bf524..9593b580ca4 100644
--- a/auto/Wrap/libBornAgainBase_wrap.cpp
+++ b/auto/Wrap/libBornAgainBase_wrap.cpp
@@ -25910,6 +25910,52 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Scale_unit(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Scale *arg1 = (Scale *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::string result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Scale, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scale_unit" "', argument " "1"" of type '" "Scale const *""'");
+ }
+ arg1 = reinterpret_cast< Scale * >(argp1);
+ result = ((Scale const *)arg1)->unit();
+ resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Scale_plottableScale(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Scale *arg1 = (Scale *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ SwigValueWrapper< Scale > result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Scale, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Scale_plottableScale" "', argument " "1"" of type '" "Scale const *""'");
+ }
+ arg1 = reinterpret_cast< Scale * >(argp1);
+ result = ((Scale const *)arg1)->plottableScale();
+ resultobj = SWIG_NewPointerObj((new Scale(result)), SWIGTYPE_p_Scale, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_delete_Scale(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Scale *arg1 = (Scale *) 0 ;
@@ -26602,6 +26648,29 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Frame_plottableFrame(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Frame *arg1 = (Frame *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ Frame *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Frame, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Frame_plottableFrame" "', argument " "1"" of type '" "Frame const *""'");
+ }
+ arg1 = reinterpret_cast< Frame * >(argp1);
+ result = (Frame *)((Frame const *)arg1)->plottableFrame();
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Frame, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *Frame_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
@@ -28642,6 +28711,8 @@ static PyMethodDef SwigMethods[] = {
"Scale_clipped(Scale self, pvacuum_double_t bounds) -> Scale\n"
""},
{ "Scale___eq__", _wrap_Scale___eq__, METH_VARARGS, "Scale___eq__(Scale self, Scale right) -> bool"},
+ { "Scale_unit", _wrap_Scale_unit, METH_O, "Scale_unit(Scale self) -> std::string"},
+ { "Scale_plottableScale", _wrap_Scale_plottableScale, METH_O, "Scale_plottableScale(Scale self) -> Scale"},
{ "delete_Scale", _wrap_delete_Scale, METH_O, "delete_Scale(Scale self)"},
{ "Scale_swigregister", Scale_swigregister, METH_O, NULL},
{ "Scale_swiginit", Scale_swiginit, METH_VARARGS, NULL},
@@ -28666,6 +28737,7 @@ static PyMethodDef SwigMethods[] = {
{ "Frame_toGlobalIndex", _wrap_Frame_toGlobalIndex, METH_VARARGS, "Frame_toGlobalIndex(Frame self, std::vector< unsigned int,std::allocator< unsigned int > > const & axes_indices) -> size_t"},
{ "Frame_hasSameSizes", _wrap_Frame_hasSameSizes, METH_VARARGS, "Frame_hasSameSizes(Frame self, Frame arg2) -> bool"},
{ "Frame___eq__", _wrap_Frame___eq__, METH_VARARGS, "Frame___eq__(Frame self, Frame arg2) -> bool"},
+ { "Frame_plottableFrame", _wrap_Frame_plottableFrame, METH_O, "Frame_plottableFrame(Frame self) -> Frame"},
{ "Frame_swigregister", Frame_swigregister, METH_O, NULL},
{ "Frame_swiginit", Frame_swiginit, METH_VARARGS, NULL},
{ "new_R3", _wrap_new_R3, METH_VARARGS, "\n"
diff --git a/auto/Wrap/libBornAgainDevice.py b/auto/Wrap/libBornAgainDevice.py
index be379a36448..da37b67beec 100644
--- a/auto/Wrap/libBornAgainDevice.py
+++ b/auto/Wrap/libBornAgainDevice.py
@@ -2076,6 +2076,14 @@ class Datafield(object):
r"""clone(Datafield self) -> Datafield"""
return _libBornAgainDevice.Datafield_clone(self)
+ def setTitle(self, title):
+ r"""setTitle(Datafield self, std::string const & title)"""
+ return _libBornAgainDevice.Datafield_setTitle(self, title)
+
+ def title(self):
+ r"""title(Datafield self) -> std::string"""
+ return _libBornAgainDevice.Datafield_title(self)
+
def setAt(self, i, val):
r"""setAt(Datafield self, size_t i, double val)"""
return _libBornAgainDevice.Datafield_setAt(self, i, val)
@@ -2084,6 +2092,10 @@ class Datafield(object):
r"""valAt(Datafield self, size_t i) -> double"""
return _libBornAgainDevice.Datafield_valAt(self, i)
+ def npArray(self):
+ r"""npArray(Datafield self) -> PyObject *"""
+ return _libBornAgainDevice.Datafield_npArray(self)
+
def frame(self):
r"""frame(Datafield self) -> Frame"""
return _libBornAgainDevice.Datafield_frame(self)
@@ -2124,6 +2136,10 @@ class Datafield(object):
r"""minVal(Datafield self) -> double"""
return _libBornAgainDevice.Datafield_minVal(self)
+ def plottableField(self):
+ r"""plottableField(Datafield self) -> Datafield"""
+ return _libBornAgainDevice.Datafield_plottableField(self)
+
def scale(self, factor):
r"""scale(Datafield self, double factor)"""
return _libBornAgainDevice.Datafield_scale(self, factor)
@@ -2135,10 +2151,6 @@ class Datafield(object):
"""
return _libBornAgainDevice.Datafield_crop(self, *args)
- def npArray(self):
- r"""npArray(Datafield self) -> PyObject *"""
- return _libBornAgainDevice.Datafield_npArray(self)
-
def xProjection(self, *args):
r"""
xProjection(Datafield self) -> Datafield
@@ -2155,14 +2167,6 @@ class Datafield(object):
"""
return _libBornAgainDevice.Datafield_yProjection(self, *args)
- def setTitle(self, title):
- r"""setTitle(Datafield self, std::string const & title)"""
- return _libBornAgainDevice.Datafield_setTitle(self, title)
-
- def title(self):
- r"""title(Datafield self) -> std::string"""
- return _libBornAgainDevice.Datafield_title(self)
-
# Register Datafield in _libBornAgainDevice:
_libBornAgainDevice.Datafield_swigregister(Datafield)
class Beam(libBornAgainParam.INode):
diff --git a/auto/Wrap/libBornAgainDevice_wrap.cpp b/auto/Wrap/libBornAgainDevice_wrap.cpp
index 32c3cd46f6d..80f1ccbd354 100644
--- a/auto/Wrap/libBornAgainDevice_wrap.cpp
+++ b/auto/Wrap/libBornAgainDevice_wrap.cpp
@@ -28244,6 +28244,65 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Datafield_setTitle(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Datafield *arg1 = (Datafield *) 0 ;
+ std::string *arg2 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "Datafield_setTitle", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_setTitle" "', argument " "1"" of type '" "Datafield *""'");
+ }
+ arg1 = reinterpret_cast< Datafield * >(argp1);
+ {
+ std::string *ptr = (std::string *)0;
+ res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Datafield_setTitle" "', argument " "2"" of type '" "std::string const &""'");
+ }
+ if (!ptr) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Datafield_setTitle" "', argument " "2"" of type '" "std::string const &""'");
+ }
+ arg2 = ptr;
+ }
+ (arg1)->setTitle((std::string const &)*arg2);
+ resultobj = SWIG_Py_Void();
+ if (SWIG_IsNewObj(res2)) delete arg2;
+ return resultobj;
+fail:
+ if (SWIG_IsNewObj(res2)) delete arg2;
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_Datafield_title(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Datafield *arg1 = (Datafield *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ std::string result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_title" "', argument " "1"" of type '" "Datafield *""'");
+ }
+ arg1 = reinterpret_cast< Datafield * >(argp1);
+ result = (arg1)->title();
+ resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_Datafield_setAt(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Datafield *arg1 = (Datafield *) 0 ;
@@ -28311,6 +28370,29 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Datafield_npArray(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Datafield *arg1 = (Datafield *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ PyObject *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_npArray" "', argument " "1"" of type '" "Datafield const *""'");
+ }
+ arg1 = reinterpret_cast< Datafield * >(argp1);
+ result = (PyObject *)((Datafield const *)arg1)->npArray();
+ resultobj = result;
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_Datafield_frame(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Datafield *arg1 = (Datafield *) 0 ;
@@ -28548,6 +28630,29 @@ fail:
}
+SWIGINTERN PyObject *_wrap_Datafield_plottableField(PyObject *self, PyObject *args) {
+ PyObject *resultobj = 0;
+ Datafield *arg1 = (Datafield *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ SwigValueWrapper< Datafield > result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_plottableField" "', argument " "1"" of type '" "Datafield const *""'");
+ }
+ arg1 = reinterpret_cast< Datafield * >(argp1);
+ result = ((Datafield const *)arg1)->plottableField();
+ resultobj = SWIG_NewPointerObj((new Datafield(result)), SWIGTYPE_p_Datafield, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
SWIGINTERN PyObject *_wrap_Datafield_scale(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
Datafield *arg1 = (Datafield *) 0 ;
@@ -28739,29 +28844,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_Datafield_npArray(PyObject *self, PyObject *args) {
- PyObject *resultobj = 0;
- Datafield *arg1 = (Datafield *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- PyObject *result = 0 ;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_npArray" "', argument " "1"" of type '" "Datafield const *""'");
- }
- arg1 = reinterpret_cast< Datafield * >(argp1);
- result = (PyObject *)((Datafield const *)arg1)->npArray();
- resultobj = result;
- return resultobj;
-fail:
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_Datafield_xProjection__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
PyObject *resultobj = 0;
Datafield *arg1 = (Datafield *) 0 ;
@@ -29064,65 +29146,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_Datafield_setTitle(PyObject *self, PyObject *args) {
- PyObject *resultobj = 0;
- Datafield *arg1 = (Datafield *) 0 ;
- std::string *arg2 = 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- int res2 = SWIG_OLDOBJ ;
- PyObject *swig_obj[2] ;
-
- if (!SWIG_Python_UnpackTuple(args, "Datafield_setTitle", 2, 2, swig_obj)) SWIG_fail;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_setTitle" "', argument " "1"" of type '" "Datafield *""'");
- }
- arg1 = reinterpret_cast< Datafield * >(argp1);
- {
- std::string *ptr = (std::string *)0;
- res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Datafield_setTitle" "', argument " "2"" of type '" "std::string const &""'");
- }
- if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Datafield_setTitle" "', argument " "2"" of type '" "std::string const &""'");
- }
- arg2 = ptr;
- }
- (arg1)->setTitle((std::string const &)*arg2);
- resultobj = SWIG_Py_Void();
- if (SWIG_IsNewObj(res2)) delete arg2;
- return resultobj;
-fail:
- if (SWIG_IsNewObj(res2)) delete arg2;
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_Datafield_title(PyObject *self, PyObject *args) {
- PyObject *resultobj = 0;
- Datafield *arg1 = (Datafield *) 0 ;
- void *argp1 = 0 ;
- int res1 = 0 ;
- PyObject *swig_obj[1] ;
- std::string result;
-
- if (!args) SWIG_fail;
- swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Datafield, 0 | 0 );
- if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Datafield_title" "', argument " "1"" of type '" "Datafield *""'");
- }
- arg1 = reinterpret_cast< Datafield * >(argp1);
- result = (arg1)->title();
- resultobj = SWIG_From_std_string(static_cast< std::string >(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
SWIGINTERN PyObject *Datafield_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
@@ -37695,8 +37718,11 @@ static PyMethodDef SwigMethods[] = {
""},
{ "delete_Datafield", _wrap_delete_Datafield, METH_O, "delete_Datafield(Datafield self)"},
{ "Datafield_clone", _wrap_Datafield_clone, METH_O, "Datafield_clone(Datafield self) -> Datafield"},
+ { "Datafield_setTitle", _wrap_Datafield_setTitle, METH_VARARGS, "Datafield_setTitle(Datafield self, std::string const & title)"},
+ { "Datafield_title", _wrap_Datafield_title, METH_O, "Datafield_title(Datafield self) -> std::string"},
{ "Datafield_setAt", _wrap_Datafield_setAt, METH_VARARGS, "Datafield_setAt(Datafield self, size_t i, double val)"},
{ "Datafield_valAt", _wrap_Datafield_valAt, METH_VARARGS, "Datafield_valAt(Datafield self, size_t i) -> double"},
+ { "Datafield_npArray", _wrap_Datafield_npArray, METH_O, "Datafield_npArray(Datafield self) -> PyObject *"},
{ "Datafield_frame", _wrap_Datafield_frame, METH_O, "Datafield_frame(Datafield self) -> Frame"},
{ "Datafield_rank", _wrap_Datafield_rank, METH_O, "Datafield_rank(Datafield self) -> size_t"},
{ "Datafield_axis", _wrap_Datafield_axis, METH_VARARGS, "Datafield_axis(Datafield self, size_t k) -> Scale"},
@@ -37707,12 +37733,12 @@ static PyMethodDef SwigMethods[] = {
{ "Datafield_flatVector", _wrap_Datafield_flatVector, METH_O, "Datafield_flatVector(Datafield self) -> vdouble1d_t"},
{ "Datafield_maxVal", _wrap_Datafield_maxVal, METH_O, "Datafield_maxVal(Datafield self) -> double"},
{ "Datafield_minVal", _wrap_Datafield_minVal, METH_O, "Datafield_minVal(Datafield self) -> double"},
+ { "Datafield_plottableField", _wrap_Datafield_plottableField, METH_O, "Datafield_plottableField(Datafield self) -> Datafield"},
{ "Datafield_scale", _wrap_Datafield_scale, METH_VARARGS, "Datafield_scale(Datafield self, double factor)"},
{ "Datafield_crop", _wrap_Datafield_crop, METH_VARARGS, "\n"
"Datafield_crop(Datafield self, double xmin, double ymin, double xmax, double ymax) -> Datafield\n"
"Datafield_crop(Datafield self, double xmin, double xmax) -> Datafield\n"
""},
- { "Datafield_npArray", _wrap_Datafield_npArray, METH_O, "Datafield_npArray(Datafield self) -> PyObject *"},
{ "Datafield_xProjection", _wrap_Datafield_xProjection, METH_VARARGS, "\n"
"Datafield_xProjection(Datafield self) -> Datafield\n"
"Datafield_xProjection(Datafield self, double yvalue) -> Datafield\n"
@@ -37723,8 +37749,6 @@ static PyMethodDef SwigMethods[] = {
"Datafield_yProjection(Datafield self, double xvalue) -> Datafield\n"
"Datafield_yProjection(Datafield self, double xlow, double xup) -> Datafield\n"
""},
- { "Datafield_setTitle", _wrap_Datafield_setTitle, METH_VARARGS, "Datafield_setTitle(Datafield self, std::string const & title)"},
- { "Datafield_title", _wrap_Datafield_title, METH_O, "Datafield_title(Datafield self) -> std::string"},
{ "Datafield_swigregister", Datafield_swigregister, METH_O, NULL},
{ "Datafield_swiginit", Datafield_swiginit, METH_VARARGS, NULL},
{ "new_Beam", _wrap_new_Beam, METH_VARARGS, "Beam(double intensity, double wavelength, double alpha, double phi=0)"},
diff --git a/auto/Wrap/libBornAgainFit.py b/auto/Wrap/libBornAgainFit.py
index 3da65c51ee2..0a6d5ebba17 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble1d_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble2d_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_integer_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vinteger2d_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_longinteger_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_complex_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_string_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
+ __getitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
- __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
+ __setitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
"""
return _libBornAgainFit.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
+ __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, 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 70f8897d16e..564bd7a6a68 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_SLICEOBJECT PyObject
+# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
-# define SWIGPY_SLICEOBJECT PySliceObject
+# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< double >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< int >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< unsigned long >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< unsigned long >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::string >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::string >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\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__(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__(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__(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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\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, 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, 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, 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, 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 f244406722f..a8eb8a1edb1 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble1d_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble2d_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_integer_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vinteger2d_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_longinteger_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_complex_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_string_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
+ __getitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
- __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
+ __setitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
+ __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, 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_parsample_t self, PySliceObject * slice)
"""
return _libBornAgainParam.vector_parsample_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice) -> vector_parsample_t
+ __getitem__(vector_parsample_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_parsample_t v)
- __setitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_parsample_t self, PySliceObject * slice, vector_parsample_t v)
+ __setitem__(vector_parsample_t self, PySliceObject * 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 e61c1967d2e..e0553d7ef58 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_SLICEOBJECT PyObject
+# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
-# define SWIGPY_SLICEOBJECT PySliceObject
+# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< ParameterSample,std::allocator< ParameterSample > > *std_vector_Sl_ParameterSample_Sg____getitem____SWIG_0(std::vector< ParameterSample > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< ParameterSample,std::allocator< ParameterSample > > const &v){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_0(std::vector< ParameterSample > *self,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____setitem____SWIG_1(std::vector< ParameterSample > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_ParameterSample_Sg____delitem____SWIG_1(std::vector< ParameterSample > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< double >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< int >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< unsigned long >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< unsigned long >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::string >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::string >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< INode const * >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< INode const * >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
+ " std::vector< INode const * >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_parsample_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< ParameterSample >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< ParameterSample >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< ParameterSample,std::allocator< ParameterSample > > const &)\n"
- " std::vector< ParameterSample >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< ParameterSample >::__setitem__(PySliceObject *,std::vector< ParameterSample,std::allocator< ParameterSample > > const &)\n"
+ " std::vector< ParameterSample >::__setitem__(PySliceObject *)\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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\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, 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector\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, 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_parsample_t___delitem__(vector_parsample_t self, PySliceObject * slice)\n"
""},
{ "vector_parsample_t___getitem__", _wrap_vector_parsample_t___getitem__, METH_VARARGS, "\n"
- "vector_parsample_t___getitem__(vector_parsample_t self, SWIGPY_SLICEOBJECT * slice) -> vector_parsample_t\n"
+ "vector_parsample_t___getitem__(vector_parsample_t self, PySliceObject * 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, 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, 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, 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/libBornAgainSample.py b/auto/Wrap/libBornAgainSample.py
index 0d6bc8c80fc..373fba1a4f5 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble1d_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vdouble1d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t
+ __getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)
- __setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble1d_t self, PySliceObject * slice, vdouble1d_t v)
+ __setitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vdouble2d_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vdouble2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t
+ __getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)
- __setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vdouble2d_t self, PySliceObject * slice, vdouble2d_t v)
+ __setitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_integer_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_integer_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t
+ __getitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_integer_t v)
- __setitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_integer_t self, PySliceObject * slice, vector_integer_t v)
+ __setitem__(vector_integer_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vinteger2d_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vinteger2d_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t
+ __getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)
- __setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vinteger2d_t self, PySliceObject * slice, vinteger2d_t v)
+ __setitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_longinteger_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_longinteger_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t
+ __getitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_longinteger_t v)
- __setitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_longinteger_t self, PySliceObject * slice, vector_longinteger_t v)
+ __setitem__(vector_longinteger_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_complex_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_complex_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t
+ __getitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_complex_t v)
- __setitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_complex_t self, PySliceObject * slice, vector_complex_t v)
+ __setitem__(vector_complex_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_string_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_string_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t
+ __getitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_string_t v)
- __setitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_string_t self, PySliceObject * slice, vector_string_t v)
+ __setitem__(vector_string_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_pvacuum_double_t self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_pvacuum_double_t___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t
+ __getitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_pvacuum_double_t v)
- __setitem__(vector_pvacuum_double_t self, SWIGPY_SLICEOBJECT * slice)
+ __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, 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(vector_R3 self, PySliceObject * slice)
"""
return _libBornAgainSample.vector_R3___delitem__(self, *args)
def __getitem__(self, *args):
r"""
- __getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3
+ __getitem__(vector_R3 self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_R3 v)
- __setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)
+ __setitem__(vector_R3 self, PySliceObject * slice, vector_R3 v)
+ __setitem__(vector_R3 self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice)
+ __delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector
+ __getitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, 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, 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, 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 f98d01d50ba..19346127733 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_SLICEOBJECT PyObject
+# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
-# define SWIGPY_SLICEOBJECT PySliceObject
+# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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:/home/svechnikov/Projects/swig-4.1.0/installed/share/swig/4.1.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_ (/*@SWIG:/usr/share/swig4.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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+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){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_Vec3_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Vec3< double > > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return NULL;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *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,PySliceObject *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(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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,SWIGPY_SLICEOBJECT *slice){
+SWIGINTERN void std_vector_Sl_INode_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< INode const * > *self,PySliceObject *slice){
Py_ssize_t i, j, step;
if( !PySlice_Check(slice) ) {
SWIG_Error(SWIG_TypeError, "Slice object expected.");
return;
}
- PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
+ PySlice_GetIndices(SWIGPY_SLICE_ARG(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble1d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< double >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
- " std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
+ " std::vector< double >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vdouble2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_integer_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< int >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__getitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
- " std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
+ " std::vector< int >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vinteger2d_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::vector< int > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::vector< int > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_longinteger_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< unsigned long >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< unsigned long >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+ " std::vector< unsigned long >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_complex_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::complex< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::complex< double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_string_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::string >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::string >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
+ " std::vector< std::string >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_pvacuum_double_t___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< std::pair< double,double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< std::pair< double,double > >::__getitem__(PySliceObject *)\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__(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__(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__(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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_R3___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< Vec3< double > >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< Vec3< double > >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< Vec3< double >,std::allocator< Vec3< double > > > const &)\n"
+ " std::vector< Vec3< double > >::__setitem__(PySliceObject *)\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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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 ;
- SWIGPY_SLICEOBJECT *arg2 = (SWIGPY_SLICEOBJECT *) 0 ;
+ PySliceObject *arg2 = (PySliceObject *) 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 '" "SWIGPY_SLICEOBJECT *""'");
+ SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "swig_dummy_type_const_inode_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
}
- arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
+ arg2 = (PySliceObject *) 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__(SWIGPY_SLICEOBJECT *)\n");
+ " std::vector< INode const * >::__delitem__(PySliceObject *)\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__(SWIGPY_SLICEOBJECT *)\n"
+ " std::vector< INode const * >::__getitem__(PySliceObject *)\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__(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__(PySliceObject *,std::vector< INode const *,std::allocator< INode const * > > const &)\n"
+ " std::vector< INode const * >::__setitem__(PySliceObject *)\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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble1d_t___delitem__(vdouble1d_t self, PySliceObject * slice)\n"
""},
{ "vdouble1d_t___getitem__", _wrap_vdouble1d_t___getitem__, METH_VARARGS, "\n"
- "vdouble1d_t___getitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble1d_t\n"
+ "vdouble1d_t___getitem__(vdouble1d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble1d_t v)\n"
- "vdouble1d_t___setitem__(vdouble1d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vdouble2d_t___delitem__(vdouble2d_t self, PySliceObject * slice)\n"
""},
{ "vdouble2d_t___getitem__", _wrap_vdouble2d_t___getitem__, METH_VARARGS, "\n"
- "vdouble2d_t___getitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice) -> vdouble2d_t\n"
+ "vdouble2d_t___getitem__(vdouble2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vdouble2d_t v)\n"
- "vdouble2d_t___setitem__(vdouble2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_integer_t___delitem__(vector_integer_t self, PySliceObject * slice)\n"
""},
{ "vector_integer_t___getitem__", _wrap_vector_integer_t___getitem__, METH_VARARGS, "\n"
- "vector_integer_t___getitem__(vector_integer_t self, SWIGPY_SLICEOBJECT * slice) -> vector_integer_t\n"
+ "vector_integer_t___getitem__(vector_integer_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vinteger2d_t___delitem__(vinteger2d_t self, PySliceObject * slice)\n"
""},
{ "vinteger2d_t___getitem__", _wrap_vinteger2d_t___getitem__, METH_VARARGS, "\n"
- "vinteger2d_t___getitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice) -> vinteger2d_t\n"
+ "vinteger2d_t___getitem__(vinteger2d_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vinteger2d_t v)\n"
- "vinteger2d_t___setitem__(vinteger2d_t self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_longinteger_t___delitem__(vector_longinteger_t self, PySliceObject * slice)\n"
""},
{ "vector_longinteger_t___getitem__", _wrap_vector_longinteger_t___getitem__, METH_VARARGS, "\n"
- "vector_longinteger_t___getitem__(vector_longinteger_t self, SWIGPY_SLICEOBJECT * slice) -> vector_longinteger_t\n"
+ "vector_longinteger_t___getitem__(vector_longinteger_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_complex_t___delitem__(vector_complex_t self, PySliceObject * slice)\n"
""},
{ "vector_complex_t___getitem__", _wrap_vector_complex_t___getitem__, METH_VARARGS, "\n"
- "vector_complex_t___getitem__(vector_complex_t self, SWIGPY_SLICEOBJECT * slice) -> vector_complex_t\n"
+ "vector_complex_t___getitem__(vector_complex_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_string_t___delitem__(vector_string_t self, PySliceObject * slice)\n"
""},
{ "vector_string_t___getitem__", _wrap_vector_string_t___getitem__, METH_VARARGS, "\n"
- "vector_string_t___getitem__(vector_string_t self, SWIGPY_SLICEOBJECT * slice) -> vector_string_t\n"
+ "vector_string_t___getitem__(vector_string_t self, PySliceObject * 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_pvacuum_double_t___delitem__(vector_pvacuum_double_t self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> vector_pvacuum_double_t\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, 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, 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, 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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "vector_R3___delitem__(vector_R3 self, PySliceObject * slice)\n"
""},
{ "vector_R3___getitem__", _wrap_vector_R3___getitem__, METH_VARARGS, "\n"
- "vector_R3___getitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice) -> vector_R3\n"
+ "vector_R3___getitem__(vector_R3 self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice, vector_R3 v)\n"
- "vector_R3___setitem__(vector_R3 self, SWIGPY_SLICEOBJECT * slice)\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, 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, SWIGPY_SLICEOBJECT * slice)\n"
+ "swig_dummy_type_const_inode_vector___delitem__(swig_dummy_type_const_inode_vector self, PySliceObject * 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, SWIGPY_SLICEOBJECT * slice) -> swig_dummy_type_const_inode_vector\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, 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, 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, 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, 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