Luigi Tibaldo / gammalib

Commit 48d0f7f845aabf14786ea7563c180f6204bb48ba

Authored by Jürgen Knödlseder
1 parent ee567a31

Resolve more SWIG warnings

Inline Side-by-side
Showing 38 changed files with 457 additions and 714 deletions
inst/cta/pyext/GCTAResponseTable.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GCTAResponseTable.i - CTA response table class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2012-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -36,76 +36,6 @@
36 36  
37 37  
38 38 /***********************************************************************//**
39   - * @brief Tuple to index conversion to provide pixel access.
40   - *
41   - * The following function provides conversion between a Python tuple and
42   - * an integer array. This allows CTAResponseTable pixel access via tuples,
43   - * such as in a[3,5,10] = 10.0 or c = a[2,9].
44   - ***************************************************************************/
45   -%{
46   -static int rsp_table_tuple(PyObject *input, int *ptr) {
47   - if (PySequence_Check(input)) {
48   - int size = PyObject_Length(input);
49   - if (size > 2) {
50   - PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
51   - return 0;
52   - }
53   - ptr[0] = size;
54   - for (int i = 0; i < size; i++) {
55   - PyObject *o = PySequence_GetItem(input,i);
56   - if (!PyInt_Check(o)) {
57   - Py_XDECREF(o);
58   - PyErr_SetString(PyExc_ValueError,"Expecting a tuple of integers");
59   - return 0;
60   - }
61   - ptr[i+1] = (int)PyInt_AsLong(o);
62   - Py_DECREF(o);
63   - }
64   - return 1;
65   - }
66   - else {
67   - ptr[0] = 1;
68   - if (!PyInt_Check(input)) {
69   - PyErr_SetString(PyExc_ValueError,"Expecting an integer");
70   - return 0;
71   - }
72   - ptr[1] = (int)PyInt_AsLong(input);
73   - return 1;
74   - }
75   -}
76   -%}
77   -
78   -// This is the typemap that makes use of the function defined above
79   -%typemap(in) int GCTAResponseTableInx[ANY](int temp[3]) {
80   - if (!rsp_table_tuple($input,temp)) {
81   - return NULL;
82   - }
83   - $1 = &temp[0];
84   -}
85   -
86   -// This typecheck verifies that all arguments are integers. The typecheck
87   -// is needed for using "int GCTAResponseTableInx" in overloaded methods.
88   -%typemap(typecheck) int GCTAResponseTableInx[ANY] {
89   - $1 = 1;
90   - if (PySequence_Check($input)) {
91   - int size = PyObject_Length($input);
92   - for (int i = 0; i < size; i++) {
93   - PyObject *o = PySequence_GetItem($input,i);
94   - if (!PyInt_Check(o)) {
95   - $1 = 0;
96   - break;
97   - }
98   - }
99   - }
100   - else {
101   - if (!PyInt_Check($input)) {
102   - $1 = 0;
103   - }
104   - }
105   -}
106   -
107   -
108   -/***********************************************************************//**
109 39 * @class GCTAResponseTable
110 40 *
111 41 * @brief Interface for the CTA response table class
... ... @@ -171,20 +101,20 @@ public:
171 101 * @brief GCTAResponse class extension
172 102 ***************************************************************************/
173 103 %extend GCTAResponseTable {
174   - double __getitem__(int GCTAResponseTableInx[]) {
175   - if (GCTAResponseTableInx[0] == 1) {
176   - return (*self)(GCTAResponseTableInx[1]);
  104 + double __getitem__(int GTuple1D2D[]) {
  105 + if (GTuple1D2D[0] == 1) {
  106 + return (*self)(GTuple1D2D[1]);
177 107 }
178 108 else {
179   - return (*self)(GCTAResponseTableInx[1], GCTAResponseTableInx[2]);
  109 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
180 110 }
181 111 }
182   - void __setitem__(int GCTAResponseTableInx[], double value) {
183   - if (GCTAResponseTableInx[0] == 1) {
184   - (*self)(GCTAResponseTableInx[1]) = value;
  112 + void __setitem__(int GTuple1D2D[], double value) {
  113 + if (GTuple1D2D[0] == 1) {
  114 + (*self)(GTuple1D2D[1]) = value;
185 115 }
186 116 else {
187   - (*self)(GCTAResponseTableInx[1], GCTAResponseTableInx[2]) = value;
  117 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
188 118 }
189 119 }
190 120 GCTAResponseTable copy() {
... ...
inst/cta/pyext/cta.i
  View file @48d0f7f
... ... @@ -82,7 +82,9 @@
82 82 %include stl.i
83 83  
84 84 /* __ Include GammaLib typemaps __________________________________________ */
  85 +%include typemap_GChatter.i
85 86 %include typemap_GFilename.i
  87 +%include typemap_GTuple.i
86 88 %include typemap_slices.i
87 89  
88 90 /* __ Include interface classes __________________________________________ */
... ...
pyext/GCsv.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GCsv.i - Comma-separated values table class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -31,53 +31,6 @@
31 31  
32 32  
33 33 /***********************************************************************//**
34   - * @brief Tuple to index conversion to provide element access.
35   - *
36   - * The following function provides conversion between a Python tuple and
37   - * an integer array. This allows table element access via tuples, such as in
38   - * a[3,5] = 10.0 or c = a[2,9]. Note that the typemap will be globally
39   - * defined after inclusing of this file.
40   - ***************************************************************************/
41   -%{
42   -static int csv_tuple(PyObject *input, int *ptr) {
43   - if (PySequence_Check(input)) {
44   - int size = PyObject_Length(input);
45   - if (size > 2) {
46   - PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
47   - return 0;
48   - }
49   - for (int i = 0; i < size; i++) {
50   - PyObject *o = PySequence_GetItem(input,i);
51   - if (!PyInt_Check(o)) {
52   - Py_XDECREF(o);
53   - PyErr_SetString(PyExc_ValueError,"Expecting a tuple of integers");
54   - return 0;
55   - }
56   - ptr[i] = (int)PyInt_AsLong(o);
57   - Py_DECREF(o);
58   - }
59   - return 1;
60   - }
61   - else {
62   - ptr[0] = 1;
63   - if (!PyInt_Check(input)) {
64   - PyErr_SetString(PyExc_ValueError,"Expecting an integer");
65   - return 0;
66   - }
67   - ptr[1] = (int)PyInt_AsLong(input);
68   - return 1;
69   - }
70   -}
71   -%}
72   -%typemap(in) int GCsvInx[ANY](int temp[2]) {
73   - if (!csv_tuple($input,temp)) {
74   - return NULL;
75   - }
76   - $1 = &temp[0];
77   -}
78   -
79   -
80   -/***********************************************************************//**
81 34 * @class GCsv
82 35 *
83 36 * @brief Comma-separated values table class definition
... ... @@ -117,11 +70,11 @@ public:
117 70 * @brief GCsv class extension
118 71 ***************************************************************************/
119 72 %extend GCsv {
120   - std::string __getitem__(int GCsvInx[]) {
121   - return (*self)(GCsvInx[0], GCsvInx[1]);
  73 + std::string __getitem__(int GTuple2D[]) {
  74 + return (*self)(GTuple2D[0], GTuple2D[1]);
122 75 }
123   - void __setitem__(int GCsvInx[], std::string value) {
124   - (*self)(GCsvInx[0], GCsvInx[1]) = value;
  76 + void __setitem__(int GTuple2D[], std::string value) {
  77 + (*self)(GTuple2D[0], GTuple2D[1]) = value;
125 78 }
126 79 int __len__() {
127 80 return (self->size());
... ...
pyext/GFitsImageByte.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageByte.i - FITS Byte image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (unsigned char*)malloc(num*sizeof(unsigned char));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageDouble.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageDouble.i - Double precision FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (double*)malloc(num*sizeof(double));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyFloat_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageFloat.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageFloat.i - Single precision FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,7 +33,7 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (float*)malloc(num*sizeof(float));
39 39 for (int i = 0; i < num; ++i) {
... ...
pyext/GFitsImageLong.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageLong.i - Long integer FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (long*)malloc(num*sizeof(long));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageLongLong.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageLongLong.i - Long long integer FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (long long*)malloc(num*sizeof(long long));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageSByte.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageSByte.i - Signed Byte FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (char*)malloc(num*sizeof(char));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageShort.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageShort.i - Short integer FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (short*)malloc(num*sizeof(short));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageULong.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageULong.i - Unsigned long image FITS class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (unsigned long*)malloc(num*sizeof(unsigned long));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsImageUShort.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsImageUShort.i - Unsigned short FITS image class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -33,10 +33,10 @@
33 33 if (!PyList_Check($input)) {
34 34 SWIG_exception(SWIG_ValueError, "List expected");
35 35 }
36   - int num = PyList_Size($input);
  36 + Py_ssize_t num = PyList_Size($input);
37 37 if (num > 0) {
38 38 $1 = (unsigned short*)malloc(num*sizeof(unsigned short));
39   - for (int i = 0; i < num; i++) {
  39 + for (int i = 0; i < num; ++i) {
40 40 PyObject *s = PyList_GetItem($input,i);
41 41 if (!PyInt_Check(s)) {
42 42 free($1);
... ...
pyext/GFitsTable.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTable.i - FITS abstract table base class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -28,77 +28,6 @@
28 28 #include "GFitsTable.hpp"
29 29 %}
30 30  
31   -/***********************************************************************//**
32   - * @brief Tuple to index conversion to provide column access.
33   - *
34   - * The following function provides conversion between a Python tuple and
35   - * an integer array. This allows table column access via tuples, such as in
36   - * a[(3,5,10)] = 10.0 or c = a[(2,9)]. Note that the typemap will be
37   - * globally defined after inclusing of this file, hence GFitsTable.i has
38   - * to be included before all table class swig files.
39   - ***************************************************************************/
40   -%{
41   -static int table_column_tuple(PyObject *input, int *ptr) {
42   - if (PySequence_Check(input)) {
43   - int size = PyObject_Length(input);
44   - if (size > 2) {
45   - PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
46   - return 0;
47   - }
48   - ptr[0] = size;
49   - for (int i = 0; i < size; i++) {
50   - PyObject *o = PySequence_GetItem(input,i);
51   - if (!PyInt_Check(o)) {
52   - Py_XDECREF(o);
53   - PyErr_SetString(PyExc_ValueError,"Expecting a tuple of integers");
54   - return 0;
55   - }
56   - ptr[i+1] = (int)PyInt_AsLong(o);
57   - Py_DECREF(o);
58   - }
59   - return 1;
60   - }
61   - else {
62   - ptr[0] = 1;
63   - if (!PyInt_Check(input)) {
64   - PyErr_SetString(PyExc_ValueError,"Expecting an integer");
65   - return 0;
66   - }
67   - ptr[1] = (int)PyInt_AsLong(input);
68   - return 1;
69   - }
70   -}
71   -%}
72   -
73   -// This is the typemap that makes use of the function defined above
74   -%typemap(in) int GFitsTableColInx[ANY](int temp[3]) {
75   - if (!table_column_tuple($input,temp)) {
76   - return NULL;
77   - }
78   - $1 = &temp[0];
79   -}
80   -
81   -// This typecheck verifies that all arguments are integers. The typecheck
82   -// is needed for using "int GFitsTableColInx" in overloaded methods.
83   -%typemap(typecheck) int GFitsTableColInx[ANY] {
84   - $1 = 1;
85   - if (PySequence_Check($input)) {
86   - int size = PyObject_Length($input);
87   - for (int i = 0; i < size; i++) {
88   - PyObject *o = PySequence_GetItem($input,i);
89   - if (!PyInt_Check(o)) {
90   - $1 = 0;
91   - break;
92   - }
93   - }
94   - }
95   - else {
96   - if (!PyInt_Check($input)) {
97   - $1 = 0;
98   - }
99   - }
100   -}
101   -
102 31  
103 32 /***********************************************************************//**
104 33 * @class GFitsTable
... ...
pyext/GFitsTableBitCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableBitCol.i - FITS table bit column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableBitCol {
73   - bool __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + bool __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], bool value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], bool value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableBoolCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableBoolCol.i - FITS table boolean column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableBoolCol {
73   - bool __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + bool __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], bool value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], bool value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableByteCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableByteCol.i - FITS table Byte column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableByteCol {
73   - unsigned char __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + unsigned char __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], unsigned char value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], unsigned char value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableCDoubleCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableCDoubleCol.i - FITS table double precision complex column *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -74,44 +74,43 @@ public:
74 74 ***************************************************************************/
75 75 %extend GFitsTableCDoubleCol {
76 76 /*
77   - GFits::cdouble __getitem__(int GFitsTableColInx[]) {
78   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  77 + GFits::cdouble __getitem__(int GTuple1D2D[]) {
  78 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
79 79 throw GException::out_of_range("__getitem__()", "Row index",
80   - GFitsTableColInx[1], self->nrows());
  80 + GTuple1D2D[1], self->nrows());
81 81 }
82   - if (GFitsTableColInx[0] == 1) {
83   - return (*self)(GFitsTableColInx[1]);
  82 + if (GTuple1D2D[0] == 1) {
  83 + return (*self)(GTuple1D2D[1]);
84 84 }
85 85 else {
86   - if (GFitsTableColInx[2] >= 0 &&
87   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
88   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  86 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  87 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
89 88 }
90 89 else {
91 90 throw GException::out_of_range("__getitem__()", "Column index",
92   - GFitsTableColInx[2],
93   - self->elements(GFitsTableColInx[1]));
  91 + GTuple1D2D[2],
  92 + self->elements(GTuple1D2D[1]));
94 93 }
95 94 }
96 95 }
97 96 */
98   - void __setitem__(int GFitsTableColInx[], GFits::cdouble value) {
99   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  97 + void __setitem__(int GTuple1D2D[], GFits::cdouble value) {
  98 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
100 99 throw GException::out_of_range("__setitem__()", "Row index",
101   - GFitsTableColInx[1], self->nrows());
  100 + GTuple1D2D[1], self->nrows());
102 101 }
103   - if (GFitsTableColInx[0] == 1) {
104   - (*self)(GFitsTableColInx[1]) = value;
  102 + if (GTuple1D2D[0] == 1) {
  103 + (*self)(GTuple1D2D[1]) = value;
105 104 }
106 105 else {
107   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
108   - self->elements(GFitsTableColInx[1])) {
109   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  106 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] <
  107 + self->elements(GTuple1D2D[1])) {
  108 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
110 109 }
111 110 else {
112 111 throw GException::out_of_range("__setitem__()", "Column index",
113   - GFitsTableColInx[2],
114   - self->elements(GFitsTableColInx[1]));
  112 + GTuple1D2D[2],
  113 + self->elements(GTuple1D2D[1]));
115 114 }
116 115 }
117 116 }
... ...
pyext/GFitsTableCFloatCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableCFloatCol.i - FITS table single precision complex column *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -74,44 +74,42 @@ public:
74 74 ***************************************************************************/
75 75 %extend GFitsTableCFloatCol {
76 76 /*
77   - GFits::cfloat __getitem__(int GFitsTableColInx[]) {
78   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  77 + GFits::cfloat __getitem__(int GTuple1D2D[]) {
  78 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
79 79 throw GException::out_of_range("__getitem__()", "Row index",
80   - GFitsTableColInx[1], self->nrows());
  80 + GTuple1D2D[1], self->nrows());
81 81 }
82   - if (GFitsTableColInx[0] == 1) {
83   - return (*self)(GFitsTableColInx[1]);
  82 + if (GTuple1D2D[0] == 1) {
  83 + return (*self)(GTuple1D2D[1]);
84 84 }
85 85 else {
86   - if (GFitsTableColInx[2] >= 0 &&
87   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
88   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  86 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  87 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
89 88 }
90 89 else {
91 90 throw GException::out_of_range("__getitem__()", "Column index",
92   - GFitsTableColInx[2],
93   - self->elements(GFitsTableColInx[1]));
  91 + GTuple1D2D[2],
  92 + self->elements(GTuple1D2D[1]));
94 93 }
95 94 }
96 95 }
97 96 */
98   - void __setitem__(int GFitsTableColInx[], GFits::cfloat value) {
99   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  97 + void __setitem__(int GTuple1D2D[], GFits::cfloat value) {
  98 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
100 99 throw GException::out_of_range("__setitem__()", "Row index",
101   - GFitsTableColInx[1], self->nrows());
  100 + GTuple1D2D[1], self->nrows());
102 101 }
103   - if (GFitsTableColInx[0] == 1) {
104   - (*self)(GFitsTableColInx[1]) = value;
  102 + if (GTuple1D2D[0] == 1) {
  103 + (*self)(GTuple1D2D[1]) = value;
105 104 }
106 105 else {
107   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
108   - self->elements(GFitsTableColInx[1])) {
109   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  106 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  107 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
110 108 }
111 109 else {
112 110 throw GException::out_of_range("__setitem__()", "Column index",
113   - GFitsTableColInx[2],
114   - self->elements(GFitsTableColInx[1]));
  111 + GTuple1D2D[2],
  112 + self->elements(GTuple1D2D[1]));
115 113 }
116 114 }
117 115 }
... ...
pyext/GFitsTableCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableCol.i - FITS abstract table column base class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -42,27 +42,6 @@
42 42 %}
43 43 %include "std_vector.i"
44 44  
45   -// This typecheck verifies that all arguments are integers. The typecheck
46   -// is needed for using "int GFitsTableColInx" in overloaded methods.
47   -%typemap(typecheck, precedence=SWIG_TYPECHECK_INTEGER) int GFitsTableColInx[ANY] {
48   - $1 = 1;
49   - if (PySequence_Check($input)) {
50   - int size = PyObject_Length($input);
51   - for (int i = 0; i < size; i++) {
52   - PyObject *o = PySequence_GetItem($input,i);
53   - if (!PyInt_Check(o)) {
54   - $1 = 0;
55   - break;
56   - }
57   - }
58   - }
59   - else {
60   - if (!PyInt_Check($input)) {
61   - $1 = 0;
62   - }
63   - }
64   -}
65   -
66 45  
67 46 /***********************************************************************//**
68 47 * @class GFitsTableCol
... ... @@ -141,120 +120,120 @@ public:
141 120 * @todo Add range checking for type casting
142 121 ***************************************************************************/
143 122 %extend GFitsTableCol {
144   -
  123 +
145 124 // String setting
146   - void __setitem__(int GFitsTableColInx[], std::string value) {
  125 + void __setitem__(int GTuple1D2D[], std::string value) {
147 126 if (dynamic_cast<GFitsTableStringCol*>(self) != NULL) {
148 127 GFitsTableStringCol* col = dynamic_cast<GFitsTableStringCol*>(self);
149   - if (GFitsTableColInx[0] == 1)
150   - (*col)(GFitsTableColInx[1]) = value;
  128 + if (GTuple1D2D[0] == 1)
  129 + (*col)(GTuple1D2D[1]) = value;
151 130 else
152   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  131 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = value;
153 132 }
154 133 else {
155 134 throw GException::bad_type("GFitsTableCol::__setitem__",
156   - "Column type does not support string setting.");
  135 + "Column type does not support string setting.");
157 136 }
158 137 }
159   -
  138 +
160 139 // Integer setting
161   - void __setitem__(int GFitsTableColInx[], int value) {
  140 + void __setitem__(int GTuple1D2D[], int value) {
162 141 if (dynamic_cast<GFitsTableBitCol*>(self) != NULL) {
163 142 GFitsTableBitCol* col = dynamic_cast<GFitsTableBitCol*>(self);
164   - if (GFitsTableColInx[0] == 1)
165   - (*col)(GFitsTableColInx[1]) = (bool)value;
  143 + if (GTuple1D2D[0] == 1)
  144 + (*col)(GTuple1D2D[1]) = (bool)value;
166 145 else
167   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (bool)value;
  146 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (bool)value;
168 147 }
169 148 else if (dynamic_cast<GFitsTableBoolCol*>(self) != NULL) {
170 149 GFitsTableBoolCol* col = dynamic_cast<GFitsTableBoolCol*>(self);
171   - if (GFitsTableColInx[0] == 1)
172   - (*col)(GFitsTableColInx[1]) = (bool)value;
  150 + if (GTuple1D2D[0] == 1)
  151 + (*col)(GTuple1D2D[1]) = (bool)value;
173 152 else
174   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (bool)value;
  153 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (bool)value;
175 154 }
176 155 else if (dynamic_cast<GFitsTableByteCol*>(self) != NULL) {
177 156 GFitsTableByteCol* col = dynamic_cast<GFitsTableByteCol*>(self);
178   - if (GFitsTableColInx[0] == 1)
179   - (*col)(GFitsTableColInx[1]) = (unsigned char)value;
  157 + if (GTuple1D2D[0] == 1)
  158 + (*col)(GTuple1D2D[1]) = (unsigned char)value;
180 159 else
181   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (unsigned char)value;
  160 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (unsigned char)value;
182 161 }
183 162 else if (dynamic_cast<GFitsTableLongCol*>(self) != NULL) {
184 163 GFitsTableLongCol* col = dynamic_cast<GFitsTableLongCol*>(self);
185   - if (GFitsTableColInx[0] == 1)
186   - (*col)(GFitsTableColInx[1]) = (long)value;
  164 + if (GTuple1D2D[0] == 1)
  165 + (*col)(GTuple1D2D[1]) = (long)value;
187 166 else
188   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (long)value;
  167 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (long)value;
189 168 }
190 169 else if (dynamic_cast<GFitsTableLongLongCol*>(self) != NULL) {
191 170 GFitsTableLongLongCol* col = dynamic_cast<GFitsTableLongLongCol*>(self);
192   - if (GFitsTableColInx[0] == 1)
193   - (*col)(GFitsTableColInx[1]) = (long long)value;
  171 + if (GTuple1D2D[0] == 1)
  172 + (*col)(GTuple1D2D[1]) = (long long)value;
194 173 else
195   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (long long)value;
  174 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (long long)value;
196 175 }
197 176 else if (dynamic_cast<GFitsTableShortCol*>(self) != NULL) {
198 177 GFitsTableShortCol* col = dynamic_cast<GFitsTableShortCol*>(self);
199   - if (GFitsTableColInx[0] == 1)
200   - (*col)(GFitsTableColInx[1]) = (short)value;
  178 + if (GTuple1D2D[0] == 1)
  179 + (*col)(GTuple1D2D[1]) = (short)value;
201 180 else
202   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (short)value;
  181 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (short)value;
203 182 }
204 183 else if (dynamic_cast<GFitsTableULongCol*>(self) != NULL) {
205 184 GFitsTableULongCol* col = dynamic_cast<GFitsTableULongCol*>(self);
206   - if (GFitsTableColInx[0] == 1)
207   - (*col)(GFitsTableColInx[1]) = (unsigned long)value;
  185 + if (GTuple1D2D[0] == 1)
  186 + (*col)(GTuple1D2D[1]) = (unsigned long)value;
208 187 else
209   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (unsigned long)value;
  188 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (unsigned long)value;
210 189 }
211 190 else if (dynamic_cast<GFitsTableUShortCol*>(self) != NULL) {
212 191 GFitsTableUShortCol* col = dynamic_cast<GFitsTableUShortCol*>(self);
213   - if (GFitsTableColInx[0] == 1)
214   - (*col)(GFitsTableColInx[1]) = (unsigned short)value;
  192 + if (GTuple1D2D[0] == 1)
  193 + (*col)(GTuple1D2D[1]) = (unsigned short)value;
215 194 else
216   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (unsigned short)value;
  195 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (unsigned short)value;
217 196 }
218 197 else if (dynamic_cast<GFitsTableDoubleCol*>(self) != NULL) {
219 198 GFitsTableDoubleCol* col = dynamic_cast<GFitsTableDoubleCol*>(self);
220   - if (GFitsTableColInx[0] == 1)
221   - (*col)(GFitsTableColInx[1]) = (double)value;
  199 + if (GTuple1D2D[0] == 1)
  200 + (*col)(GTuple1D2D[1]) = (double)value;
222 201 else
223   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (double)value;
  202 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (double)value;
224 203 }
225 204 else if (dynamic_cast<GFitsTableFloatCol*>(self) != NULL) {
226 205 GFitsTableFloatCol* col = dynamic_cast<GFitsTableFloatCol*>(self);
227   - if (GFitsTableColInx[0] == 1)
228   - (*col)(GFitsTableColInx[1]) = (float)value;
  206 + if (GTuple1D2D[0] == 1)
  207 + (*col)(GTuple1D2D[1]) = (float)value;
229 208 else
230   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (float)value;
  209 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (float)value;
231 210 }
232 211 else {
233 212 throw GException::bad_type("GFitsTableCol::__setitem__",
234   - "Column type does not support integer setting.");
  213 + "Column type does not support integer setting.");
235 214 }
236 215 }
237   -
  216 +
238 217 // Floating point setting
239   - void __setitem__(int GFitsTableColInx[], double value) {
  218 + void __setitem__(int GTuple1D2D[], double value) {
240 219 if (dynamic_cast<GFitsTableDoubleCol*>(self) != NULL) {
241 220 GFitsTableDoubleCol* col = dynamic_cast<GFitsTableDoubleCol*>(self);
242   - if (GFitsTableColInx[0] == 1)
243   - (*col)(GFitsTableColInx[1]) = value;
  221 + if (GTuple1D2D[0] == 1)
  222 + (*col)(GTuple1D2D[1]) = value;
244 223 else
245   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  224 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = value;
246 225 }
247 226 else if (dynamic_cast<GFitsTableFloatCol*>(self) != NULL) {
248 227 GFitsTableFloatCol* col = dynamic_cast<GFitsTableFloatCol*>(self);
249   - if (GFitsTableColInx[0] == 1)
250   - (*col)(GFitsTableColInx[1]) = (float)value;
  228 + if (GTuple1D2D[0] == 1)
  229 + (*col)(GTuple1D2D[1]) = (float)value;
251 230 else
252   - (*col)(GFitsTableColInx[1], GFitsTableColInx[2]) = (float)value;
  231 + (*col)(GTuple1D2D[1], GTuple1D2D[2]) = (float)value;
253 232 }
254 233  
255 234 else {
256 235 throw GException::bad_type("GFitsTableCol::__setitem__",
257   - "Column type does not support floating point setting.");
  236 + "Column type does not support floating point setting.");
258 237 }
259 238 }
260 239 };
... ...
pyext/GFitsTableDoubleCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableDoubleCol.i - FITS table double precision column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableDoubleCol {
73   - double __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + double __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], double value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], double value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableFloatCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableFloatCol.i - FITS table single precision column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableFloatCol {
73   - float __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + float __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], float value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], float value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableLongCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableLongCol.i - FITS table long integer column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableLongCol {
73   - long __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + long __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], long value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], long value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableLongLongCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableLongLongCol.i - FITS table long long integer column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableLongLongCol {
73   - long long __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + long long __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], long long value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], long long value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableShortCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableShortCol.i - FITS table short integer column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,41 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableShortCol {
73   - short __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + short __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  83 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 84 }
86 85 else {
87 86 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  87 + GTuple1D2D[2],
  88 + self->elements(GTuple1D2D[1]));
90 89 }
91 90 }
92 91 }
93   - void __setitem__(int GFitsTableColInx[], short value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  92 + void __setitem__(int GTuple1D2D[], short value) {
  93 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 94 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  95 + GTuple1D2D[1], self->nrows());
97 96 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  97 + if (GTuple1D2D[0] == 1) {
  98 + (*self)(GTuple1D2D[1]) = value;
100 99 }
101 100 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  101 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  102 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 103 }
106 104 else {
107 105 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  106 + GTuple1D2D[2],
  107 + self->elements(GTuple1D2D[1]));
110 108 }
111 109 }
112 110 }
... ...
pyext/GFitsTableStringCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableStringCol.i - FITS table string column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,63 +71,60 @@ public:
71 71 * find out how to implement this (e.g. via typemaps).
72 72 ***************************************************************************/
73 73 %extend GFitsTableStringCol {
74   - std::string __getitem__(int GFitsTableColInx[]) {
75   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  74 + std::string __getitem__(int GTuple1D2D[]) {
  75 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
76 76 throw GException::out_of_range("__getitem__()", "Row index",
77   - GFitsTableColInx[1], self->nrows());
  77 + GTuple1D2D[1], self->nrows());
78 78 }
79   - if (GFitsTableColInx[0] == 1) {
80   - return (*self)(GFitsTableColInx[1]);
  79 + if (GTuple1D2D[0] == 1) {
  80 + return (*self)(GTuple1D2D[1]);
81 81 }
82 82 else {
83   - if (GFitsTableColInx[2] >= 0 &&
84   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
85   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  83 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  84 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
86 85 }
87 86 else {
88 87 throw GException::out_of_range("__getitem__()", "Column index",
89   - GFitsTableColInx[2],
90   - self->elements(GFitsTableColInx[1]));
  88 + GTuple1D2D[2],
  89 + self->elements(GTuple1D2D[1]));
91 90 }
92 91 }
93 92 }
94   - void __setitem__(int GFitsTableColInx[], std::string value) {
95   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  93 + void __setitem__(int GTuple1D2D[], std::string value) {
  94 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
96 95 throw GException::out_of_range("__setitem__()", "Row index",
97   - GFitsTableColInx[1], self->nrows());
  96 + GTuple1D2D[1], self->nrows());
98 97 }
99   - if (GFitsTableColInx[0] == 1) {
100   - (*self)(GFitsTableColInx[1]) = value;
  98 + if (GTuple1D2D[0] == 1) {
  99 + (*self)(GTuple1D2D[1]) = value;
101 100 }
102 101 else {
103   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
104   - self->elements(GFitsTableColInx[1])) {
105   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  102 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  103 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
106 104 }
107 105 else {
108 106 throw GException::out_of_range("__setitem__()", "Column index",
109   - GFitsTableColInx[2],
110   - self->elements(GFitsTableColInx[1]));
  107 + GTuple1D2D[2],
  108 + self->elements(GTuple1D2D[1]));
111 109 }
112 110 }
113 111 }
114   - void __setitem__(int GFitsTableColInx[], GFilename value) {
115   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  112 + void __setitem__(int GTuple1D2D[], GFilename value) {
  113 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
116 114 throw GException::out_of_range("__setitem__()", "Row index",
117   - GFitsTableColInx[1], self->nrows());
  115 + GTuple1D2D[1], self->nrows());
118 116 }
119   - if (GFitsTableColInx[0] == 1) {
120   - (*self)(GFitsTableColInx[1]) = std::string(value);
  117 + if (GTuple1D2D[0] == 1) {
  118 + (*self)(GTuple1D2D[1]) = std::string(value);
121 119 }
122 120 else {
123   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
124   - self->elements(GFitsTableColInx[1])) {
125   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = std::string(value);
  121 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  122 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = std::string(value);
126 123 }
127 124 else {
128 125 throw GException::out_of_range("__setitem__()", "Column index",
129   - GFitsTableColInx[2],
130   - self->elements(GFitsTableColInx[1]));
  126 + GTuple1D2D[2],
  127 + self->elements(GTuple1D2D[1]));
131 128 }
132 129 }
133 130 }
... ...
pyext/GFitsTableULongCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableULongCol.i - FITS table unsigned long integer column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,42 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableULongCol {
73   - unsigned long __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + unsigned long __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 &&
  83 + GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  84 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 85 }
86 86 else {
87 87 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  88 + GTuple1D2D[2],
  89 + self->elements(GTuple1D2D[1]));
90 90 }
91 91 }
92 92 }
93   - void __setitem__(int GFitsTableColInx[], unsigned long value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  93 + void __setitem__(int GTuple1D2D[], unsigned long value) {
  94 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 95 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  96 + GTuple1D2D[1], self->nrows());
97 97 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  98 + if (GTuple1D2D[0] == 1) {
  99 + (*self)(GTuple1D2D[1]) = value;
100 100 }
101 101 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  102 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  103 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 104 }
106 105 else {
107 106 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  107 + GTuple1D2D[2],
  108 + self->elements(GTuple1D2D[1]));
110 109 }
111 110 }
112 111 }
... ...
pyext/GFitsTableUShortCol.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GFitsTableUShortCol.i - FITS table unsigned short integer column class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,43 +70,42 @@ public:
70 70 * find out how to implement this (e.g. via typemaps).
71 71 ***************************************************************************/
72 72 %extend GFitsTableUShortCol {
73   - unsigned short __getitem__(int GFitsTableColInx[]) {
74   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  73 + unsigned short __getitem__(int GTuple1D2D[]) {
  74 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
75 75 throw GException::out_of_range("__getitem__()", "Row index",
76   - GFitsTableColInx[1], self->nrows());
  76 + GTuple1D2D[1], self->nrows());
77 77 }
78   - if (GFitsTableColInx[0] == 1) {
79   - return (*self)(GFitsTableColInx[1]);
  78 + if (GTuple1D2D[0] == 1) {
  79 + return (*self)(GTuple1D2D[1]);
80 80 }
81 81 else {
82   - if (GFitsTableColInx[2] >= 0 &&
83   - GFitsTableColInx[2] < self->elements(GFitsTableColInx[1])) {
84   - return (*self)(GFitsTableColInx[1], GFitsTableColInx[2]);
  82 + if (GTuple1D2D[2] >= 0 &&
  83 + GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  84 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
85 85 }
86 86 else {
87 87 throw GException::out_of_range("__getitem__()", "Column index",
88   - GFitsTableColInx[2],
89   - self->elements(GFitsTableColInx[1]));
  88 + GTuple1D2D[2],
  89 + self->elements(GTuple1D2D[1]));
90 90 }
91 91 }
92 92 }
93   - void __setitem__(int GFitsTableColInx[], unsigned short value) {
94   - if (GFitsTableColInx[1] < 0 || GFitsTableColInx[1] >= self->nrows()) {
  93 + void __setitem__(int GTuple1D2D[], unsigned short value) {
  94 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->nrows()) {
95 95 throw GException::out_of_range("__setitem__()", "Row index",
96   - GFitsTableColInx[1], self->nrows());
  96 + GTuple1D2D[1], self->nrows());
97 97 }
98   - if (GFitsTableColInx[0] == 1) {
99   - (*self)(GFitsTableColInx[1]) = value;
  98 + if (GTuple1D2D[0] == 1) {
  99 + (*self)(GTuple1D2D[1]) = value;
100 100 }
101 101 else {
102   - if (GFitsTableColInx[2] >= 0 && GFitsTableColInx[2] <
103   - self->elements(GFitsTableColInx[1])) {
104   - (*self)(GFitsTableColInx[1], GFitsTableColInx[2]) = value;
  102 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->elements(GTuple1D2D[1])) {
  103 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
105 104 }
106 105 else {
107 106 throw GException::out_of_range("__setitem__()", "Column index",
108   - GFitsTableColInx[2],
109   - self->elements(GFitsTableColInx[1]));
  107 + GTuple1D2D[2],
  108 + self->elements(GTuple1D2D[1]));
110 109 }
111 110 }
112 111 }
... ...
pyext/GMatrix.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GMatrix.i - General Matrix class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -94,11 +94,11 @@ public:
94 94 * @brief GMatrix class extension
95 95 ***************************************************************************/
96 96 %extend GMatrix {
97   - double __getitem__(int GTuple[2]) {
98   - return (*self)(GTuple[0], GTuple[1]);
  97 + double __getitem__(int GTuple2D[]) {
  98 + return (*self)(GTuple2D[0], GTuple2D[1]);
99 99 }
100   - void __setitem__(int GTuple[2], double value) {
101   - (*self)(GTuple[0], GTuple[1]) = value;
  100 + void __setitem__(int GTuple2D[], double value) {
  101 + (*self)(GTuple2D[0], GTuple2D[1]) = value;
102 102 }
103 103 GVector __mul__(const GVector& vector) {
104 104 return ((*self) * vector);
... ...
pyext/GMatrixSparse.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GMatrixSparse.i - Sparse matrix class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -108,11 +108,11 @@ public:
108 108 * @brief GMatrixSparse class extension
109 109 ***************************************************************************/
110 110 %extend GMatrixSparse {
111   - double __getitem__(int GTuple[2]) {
112   - return (*self)(GTuple[0], GTuple[1]);
  111 + double __getitem__(int GTuple2D[]) {
  112 + return (*self)(GTuple2D[0], GTuple2D[1]);
113 113 }
114   - void __setitem__(int GTuple[2], double value) {
115   - (*self)(GTuple[0], GTuple[1]) = value;
  114 + void __setitem__(int GTuple2D[], double value) {
  115 + (*self)(GTuple2D[0], GTuple2D[1]) = value;
116 116 }
117 117 GVector __mul__(const GVector& vector) {
118 118 return ((*self) * vector);
... ...
pyext/GMatrixSymmetric.i
  View file @48d0f7f
1 1 /***************************************************************************
2 2 * GMatrixSymmetric.i - Symmetric matrix class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2018 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2020 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -93,11 +93,11 @@ public:
93 93 * @brief GMatrixSymmetric class extension
94 94 ***************************************************************************/
95 95 %extend GMatrixSymmetric {
96   - double __getitem__(int GTuple[2]) {
97   - return (*self)(GTuple[0], GTuple[1]);
  96 + double __getitem__(int GTuple2D[]) {
  97 + return (*self)(GTuple2D[0], GTuple2D[1]);
98 98 }
99   - void __setitem__(int GTuple[2], double value) {
100   - (*self)(GTuple[0], GTuple[1]) = value;
  99 + void __setitem__(int GTuple2D[], double value) {
  100 + (*self)(GTuple2D[0], GTuple2D[1]) = value;
101 101 }
102 102 GVector __mul__(const GVector& vector) {
103 103 return ((*self) * vector);
... ...
pyext/GResponseVectorCache.i
  View file @48d0f7f
... ... @@ -38,8 +38,9 @@
38 38 *
39 39 */
40 40 %include "typemaps.i"
41   -%apply GVector *OUTPUT { GVector* value };
42   -
  41 +%typemap(argout) GVector *OUTPUT {
  42 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), SWIGTYPE_p_GVector, 0 | 0);
  43 +}
43 44  
44 45 /***********************************************************************//**
45 46 * @class GResponseVectorCache
... ...
pyext/GRmf.i
  View file @48d0f7f
... ... @@ -85,11 +85,11 @@ public:
85 85 * @brief GRmf class extension
86 86 ***************************************************************************/
87 87 %extend GRmf {
88   - double __getitem__(int GTuple[2]) {
89   - return self->at(GTuple[0], GTuple[1]);
  88 + double __getitem__(int GTuple2D[]) {
  89 + return self->at(GTuple2D[0], GTuple2D[1]);
90 90 }
91   - void __setitem__(int GTuple[2], const double& value) {
92   - self->at(GTuple[0], GTuple[1]) = value;
  91 + void __setitem__(int GTuple2D[], const double& value) {
  92 + self->at(GTuple2D[0], GTuple2D[1]) = value;
93 93 }
94 94 int __len__() {
95 95 return (self->size());
... ...
pyext/GSkyMap.i
  View file @48d0f7f
... ... @@ -31,76 +31,6 @@
31 31  
32 32  
33 33 /***********************************************************************//**
34   - * @brief Tuple to index conversion to provide pixel access.
35   - *
36   - * The following function provides conversion between a Python tuple and
37   - * an integer array. This allows skymap pixel access via tuples, such as in
38   - * a[3,5,10] = 10.0 or c = a[2,9].
39   - ***************************************************************************/
40   -%{
41   -static int skymap_tuple(PyObject *input, int *ptr) {
42   - if (PySequence_Check(input)) {
43   - int size = PyObject_Length(input);
44   - if (size > 2) {
45   - PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
46   - return 0;
47   - }
48   - ptr[0] = size;
49   - for (int i = 0; i < size; i++) {
50   - PyObject *o = PySequence_GetItem(input,i);
51   - if (!PyInt_Check(o)) {
52   - Py_XDECREF(o);
53   - PyErr_SetString(PyExc_ValueError,"Expecting a tuple of integers");
54   - return 0;
55   - }
56   - ptr[i+1] = (int)PyInt_AsLong(o);
57   - Py_DECREF(o);
58   - }
59   - return 1;
60   - }
61   - else {
62   - ptr[0] = 1;
63   - if (!PyInt_Check(input)) {
64   - PyErr_SetString(PyExc_ValueError,"Expecting an integer");
65   - return 0;
66   - }
67   - ptr[1] = (int)PyInt_AsLong(input);
68   - return 1;
69   - }
70   -}
71   -%}
72   -
73   -// This is the typemap that makes use of the function defined above
74   -%typemap(in) int GSkyMapInx[ANY](int temp[3]) {
75   - if (!skymap_tuple($input,temp)) {
76   - return NULL;
77   - }
78   - $1 = &temp[0];
79   -}
80   -
81   -// This typecheck verifies that all arguments are integers. The typecheck
82   -// is needed for using "int GSkyMapInx" in overloaded methods.
83   -%typemap(typecheck) int GSkyMapInx[ANY] {
84   - $1 = 1;
85   - if (PySequence_Check($input)) {
86   - int size = PyObject_Length($input);
87   - for (int i = 0; i < size; i++) {
88   - PyObject *o = PySequence_GetItem($input,i);
89   - if (!PyInt_Check(o)) {
90   - $1 = 0;
91   - break;
92   - }
93   - }
94   - }
95   - else {
96   - if (!PyInt_Check($input)) {
97   - $1 = 0;
98   - }
99   - }
100   -}
101   -
102   -
103   -/***********************************************************************//**
104 34 * @class GSkyMap
105 35 *
106 36 * @brief GSkyMap class interface definition
... ... @@ -200,23 +130,23 @@ public:
200 130 * GSkyDir
201 131 ***************************************************************************/
202 132 %extend GSkyMap {
203   - double __getitem__(int GSkyMapInx[]) {
204   - if (GSkyMapInx[1] < 0 || GSkyMapInx[1] >= self->npix()) {
  133 + double __getitem__(int GTuple1D2D[]) {
  134 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->npix()) {
205 135 throw GException::out_of_range("GSkyMap::__getitem__(int*)",
206 136 "Sky map index",
207   - GSkyMapInx[1], self->npix());
  137 + GTuple1D2D[1], self->npix());
208 138 }
209   - if (GSkyMapInx[0] == 1) {
210   - return (*self)(GSkyMapInx[1]);
  139 + if (GTuple1D2D[0] == 1) {
  140 + return (*self)(GTuple1D2D[1]);
211 141 }
212 142 else {
213   - if (GSkyMapInx[2] >= 0 && GSkyMapInx[2] < self->nmaps()) {
214   - return (*self)(GSkyMapInx[1], GSkyMapInx[2]);
  143 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->nmaps()) {
  144 + return (*self)(GTuple1D2D[1], GTuple1D2D[2]);
215 145 }
216 146 else {
217 147 throw GException::out_of_range("GSkyMap::__getitem__(int*)",
218 148 "Sky map number",
219   - GSkyMapInx[2], self->nmaps());
  149 + GTuple1D2D[2], self->nmaps());
220 150 }
221 151 }
222 152 }
... ... @@ -225,23 +155,23 @@ public:
225 155 return (*self)(pixel);
226 156 }
227 157 */
228   - void __setitem__(int GSkyMapInx[], double value) {
229   - if (GSkyMapInx[1] < 0 || GSkyMapInx[1] >= self->npix()) {
  158 + void __setitem__(int GTuple1D2D[], double value) {
  159 + if (GTuple1D2D[1] < 0 || GTuple1D2D[1] >= self->npix()) {
230 160 throw GException::out_of_range("GSkyMap::__setitem__(int*,double&)",
231 161 "Sky map index",
232   - GSkyMapInx[1], self->npix());
  162 + GTuple1D2D[1], self->npix());
233 163 }
234   - if (GSkyMapInx[0] == 1) {
235   - (*self)(GSkyMapInx[1]) = value;
  164 + if (GTuple1D2D[0] == 1) {
  165 + (*self)(GTuple1D2D[1]) = value;
236 166 }
237 167 else {
238   - if (GSkyMapInx[2] >= 0 && GSkyMapInx[2] < self->nmaps()) {
239   - (*self)(GSkyMapInx[1], GSkyMapInx[2]) = value;
  168 + if (GTuple1D2D[2] >= 0 && GTuple1D2D[2] < self->nmaps()) {
  169 + (*self)(GTuple1D2D[1], GTuple1D2D[2]) = value;
240 170 }
241 171 else {
242 172 throw GException::out_of_range("GSkyMap::__setitem__(int*,double&)",
243 173 "Sky map number",
244   - GSkyMapInx[2], self->nmaps());
  174 + GTuple1D2D[2], self->nmaps());
245 175 }
246 176 }
247 177 }
... ...
pyext/gammalib/fits.i
  View file @48d0f7f
... ... @@ -47,6 +47,7 @@ namespace std {
47 47 /* __ Include GammaLib typemaps __________________________________________ */
48 48 %include typemap_GChatter.i
49 49 %include typemap_GFilename.i
  50 +%include typemap_GTuple.i
50 51 %include typemap_slices.i
51 52  
52 53 /* __ Include interface classes __________________________________________ */
... ...
pyext/gammalib/obs.i
  View file @48d0f7f
... ... @@ -216,22 +216,6 @@
216 216 $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
217 217 }
218 218 }
219   -%typemap(out) GVector* {
220   - char classname[80];
221   - strcpy(classname, "_p_");
222   - strcat(classname, result->classname().c_str());
223   - swig_type_info *myinfo = SWIGTYPE_p_GVector;
224   - swig_cast_info *mycast = 0;
225   - mycast = myinfo->cast;
226   - while (mycast != 0) {
227   - if (strcmp(classname, mycast->type->name) == 0) {
228   - myinfo = mycast->type;
229   - break;
230   - }
231   - mycast = mycast->next;
232   - }
233   - $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
234   -}
235 219  
236 220 /* __ Observation handling _______________________________________________ */
237 221 %include "GEnergy.i"
... ...
pyext/gammalib/sky.i
  View file @48d0f7f
... ... @@ -49,6 +49,7 @@ namespace std {
49 49 /* __ Include GammaLib typemaps __________________________________________ */
50 50 %include typemap_GChatter.i
51 51 %include typemap_GFilename.i
  52 +%include typemap_GTuple.i
52 53 %include typemap_slices.i
53 54  
54 55 /* __ Include interface classes __________________________________________ */
... ...
pyext/gammalib/support.i
  View file @48d0f7f
... ... @@ -46,6 +46,7 @@
46 46 /* __ Include GammaLib typemaps __________________________________________ */
47 47 %include typemap_GChatter.i
48 48 %include typemap_GFilename.i
  49 +%include typemap_GTuple.i
49 50 %include typemap_slices.i
50 51  
51 52 /* __ Include interface classes __________________________________________ */
... ...
pyext/typemap_GTuple.i
  View file @48d0f7f
... ... @@ -36,7 +36,7 @@
36 36 * in a[3,5] = 10.0 or c = a[2,9]. A typecheck typemap is provided to allow
37 37 * overloading.
38 38 ***************************************************************************/
39   -%typemap(in) int GTuple[2] (int temp[2]) {
  39 +%typemap(in) int GTuple2D[] (int temp[2]) {
40 40 if (!PySequence_Check($input)) {
41 41 PyErr_SetString(PyExc_ValueError,"Expected a sequence");
42 42 return NULL;
... ... @@ -57,13 +57,70 @@
57 57 }
58 58 $1 = temp;
59 59 }
60   -%typemap(typecheck) int GTuple[2] {
  60 +%typemap(typecheck) int GTuple2D[] {
61 61 $1 = 1;
62 62 if (PySequence_Check($input)) {
63   - int size = PyObject_Length($input);
  63 + Py_ssize_t size = PyObject_Length($input);
  64 + for (int i = 0; i < size; ++i) {
  65 + PyObject *o = PySequence_GetItem($input,i);
  66 + if (!PyInt_Check(o)) {
  67 + $1 = 0;
  68 + break;
  69 + }
  70 + }
  71 + }
  72 + else {
  73 + if (!PyInt_Check($input)) {
  74 + $1 = 0;
  75 + }
  76 + }
  77 +}
  78 +
  79 +
  80 +/***********************************************************************//**
  81 + * @brief 1D or 2D tuple to index conversion
  82 + *
  83 + * The following typemap provides conversion between a 1-dimensional or
  84 + * or 2-dimensional Python tuple and an integer array. This allows index
  85 + * access via tuples, such as in a[3] = 10.0 or c = a[2,9]. A typecheck
  86 + * typemap is provided to allow overloading.
  87 + ***************************************************************************/
  88 +%typemap(in) int GTuple1D2D[] (int temp[3]) {
  89 + if (PySequence_Check($input)) {
  90 + Py_ssize_t size = PyObject_Length($input);
  91 + if (size > 2) {
  92 + PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
  93 + return NULL;
  94 + }
  95 + temp[0] = size;
64 96 for (int i = 0; i < size; i++) {
65 97 PyObject *o = PySequence_GetItem($input,i);
66 98 if (!PyInt_Check(o)) {
  99 + Py_XDECREF(o);
  100 + PyErr_SetString(PyExc_ValueError,"Expecting a tuple of integers");
  101 + return NULL;
  102 + }
  103 + temp[i+1] = (int)PyInt_AsLong(o);
  104 + Py_DECREF(o);
  105 + }
  106 + }
  107 + else {
  108 + temp[0] = 1;
  109 + if (!PyInt_Check($input)) {
  110 + PyErr_SetString(PyExc_ValueError,"Expecting an integer");
  111 + return NULL;
  112 + }
  113 + temp[1] = (int)PyInt_AsLong($input);
  114 + }
  115 + $1 = temp;
  116 +}
  117 +%typemap(typecheck, precedence=SWIG_TYPECHECK_INTEGER) int GTuple1D2D[] {
  118 + $1 = 1;
  119 + if (PySequence_Check($input)) {
  120 + Py_ssize_t size = PyObject_Length($input);
  121 + for (int i = 0; i < size; ++i) {
  122 + PyObject *o = PySequence_GetItem($input,i);
  123 + if (!PyInt_Check(o)) {
67 124 $1 = 0;
68 125 break;
69 126 }
... ... @@ -86,13 +143,13 @@
86 143 ***************************************************************************/
87 144 %typemap(in) int GTuple[ANY] (int temp[11]) {
88 145 if (PySequence_Check($input)) {
89   - int size = PyObject_Length($input);
  146 + Py_ssize_t size = PyObject_Length($input);
90 147 if (size > 10) {
91 148 PyErr_SetString(PyExc_ValueError,"Too many arguments in tuple");
92 149 return NULL;
93 150 }
94 151 temp[0] = size;
95   - for (int i = 0; i < size; i++) {
  152 + for (int i = 0; i < size; ++i) {
96 153 PyObject *o = PySequence_GetItem($input,i);
97 154 if (!PyInt_Check(o)) {
98 155 Py_XDECREF(o);
... ... @@ -102,7 +159,6 @@
102 159 temp[i+1] = (int)PyInt_AsLong(o);
103 160 Py_DECREF(o);
104 161 }
105   - $1 = &temp[0];
106 162 }
107 163 else {
108 164 temp[0] = 1;
... ... @@ -111,14 +167,14 @@
111 167 return NULL;
112 168 }
113 169 temp[1] = (int)PyInt_AsLong($input);
114   - $1 = &temp[0];
115 170 }
  171 + $1 = temp;
116 172 }
117 173 %typemap(typecheck) int GTuple[ANY] {
118 174 $1 = 1;
119 175 if (PySequence_Check($input)) {
120   - int size = PyObject_Length($input);
121   - for (int i = 0; i < size; i++) {
  176 + Py_ssize_t size = PyObject_Length($input);
  177 + for (int i = 0; i < size; ++i) {
122 178 PyObject *o = PySequence_GetItem($input,i);
123 179 if (!PyInt_Check(o)) {
124 180 $1 = 0;
... ...