%{

#include <ctime>

#include <datetime.h>

#include <limits>

%}

%ignore griddb::Row;

%ignore griddb::Container::getGSTypeList;

%ignore griddb::Container::getColumnCount;

%ignore griddb::RowSet::next_row;

%ignore griddb::RowSet::get_next_query_analysis;

%ignore griddb::RowSet::get_next_aggregation;

%ignore griddb::ContainerInfo::ContainerInfo(GSContainerInfo* containerInfo);

%pythonbegin %{

from enum import IntEnum

%}

%pythoncode {

class ContainerType(IntEnum):

def __int__(self):

return self._value

COLLECTION = 0

TIME_SERIES = 1

class IndexType(IntEnum):

def __int__(self):

return int(self.value)

DEFAULT = -1

TREE = 1 << 0

HASH = 1 << 1

SPATIAL = 1 << 2

class RowSetType(IntEnum):

def __int__(self):

return int(self.value)

CONTAINER_ROWS = 0

AGGREGATION_RESULT = 1

QUERY_ANALYSIS = 2

class FetchOption(IntEnum):

def __int__(self):

return int(self.value)

LIMIT = 0

class TimeUnit(IntEnum):

def __int__(self):

return int(self.value)

YEAR = 0

MONTH = 1

DAY = 2

HOUR = 3

MINUTE = 4

SECOND = 5

MILLISECOND = 6

class Type(IntEnum):

def __int__(self):

return self._value

STRING = 0

BOOL = 1

BYTE = 2

SHORT = 3

INTEGER = 4

LONG = 5

FLOAT = 6

DOUBLE = 7

TIMESTAMP = 8

GEOMETRY = 9

BLOB = 10

STRING_ARRAY = 11

BOOL_ARRAY = 12

BYTE_ARRAY = 13

SHORT_ARRAY = 14

INTEGER_ARRAY = 15

LONG_ARRAY = 16

FLOAT_ARRAY = 17

DOUBLE_ARRAY = 18

TIMESTAMP_ARRAY = 19

%#if GS_COMPATIBILITY_SUPPORT_3_5

NULL = -1

%#endif

class TypeOption(IntEnum):

def __int__(self):

return int(self.value)

NULLABLE = 1 << 1

NOT_NULL = 1 << 2

}

%include <attribute.i>

#define UTC_TIMESTAMP_MAX 253402300799.999

%feature("autodoc", "0");

%fragment("convertStrToObj", "header") {

PyObject* convertStrToObj(const GSChar* str) {

%#if PY_MAJOR_VERSION < 3

return PyString_FromString(str);

%#else

return PyUnicode_FromString(str);

%#endif

}

}

%fragment("convertObjToStr", "header") {

char* convertObjToStr(PyObject *string) {

%#if PY_MAJOR_VERSION < 3

return PyString_AsString(string);

%#else

return PyUnicode_AsUTF8(string);

%#endif

}

}

%fragment("checkPyObjIsStr", "header") {

bool checkPyObjIsStr(PyObject* obj) {

%#if PY_MAJOR_VERSION < 3

return PyString_Check(obj);

%#else

return PyUnicode_Check(obj);

%#endif

}

}

%fragment("convertTimestampToObject", "header") {

static PyObject* convertTimestampToObject(GSTimestamp* timestamp, bool timestamp_to_float = true) {

// In C-API there is function PyDateTime_FromTimestamp convert from datetime to local datetime (not UTC).

// But GridDB use UTC datetime => use the string output from gsFormatTime to convert to UTC datetime

if (timestamp_to_float) {

return PyFloat_FromDouble(((double)(*timestamp)) / 1000);

}

if (!PyDateTimeAPI) {

PyDateTime_IMPORT;

}

PyObject *dateTime = NULL;

size_t bufSize = 100;

static GSChar strBuf[100] = {0};

gsFormatTime(*timestamp, strBuf, bufSize);

//Date format is YYYY-MM-DDTHH:mm:ss.sssZ

int year;

int month;

int day;

int hour;

int minute;

int second;

int miliSecond;

int microSecond;

sscanf(strBuf, "%d-%d-%dT%d:%d:%d.%dZ", &year, &month, &day, &hour, &minute, &second, &miliSecond);

microSecond = miliSecond * 1000;

dateTime = PyDateTime_FromDateAndTime(year, month, day, hour, minute, second, microSecond);

return dateTime;

}

}

%fragment("convertFieldToObject", "header",

fragment = "convertStrToObj", fragment = "convertTimestampToObject") {

static PyObject* convertFieldToObject(griddb::Field &field, bool timestamp_to_float = true) {

PyObject* list;

int listSize, i;

void* arrayPtr;

switch (field.type) {

case GS_TYPE_BLOB: {

PyObject *o = PyByteArray_FromStringAndSize((GSChar *)field.value.asBlob.data, field.value.asBlob.size);

return o;

}

case GS_TYPE_BOOL:

return PyBool_FromLong(field.value.asBool);

case GS_TYPE_INTEGER:

return PyInt_FromLong(field.value.asInteger);

case GS_TYPE_LONG:

return PyLong_FromLong(field.value.asLong);

case GS_TYPE_FLOAT:

return PyFloat_FromDouble(field.value.asFloat);

case GS_TYPE_DOUBLE:

return PyFloat_FromDouble(field.value.asDouble);

case GS_TYPE_STRING:

return convertStrToObj(field.value.asString);

case GS_TYPE_TIMESTAMP: {

return convertTimestampToObject(&field.value.asTimestamp, timestamp_to_float);

}

%#if GS_COMPATIBILITY_SUPPORT_3_5

case GS_TYPE_NULL:

return Py_None;

%#endif

case GS_TYPE_BYTE:

return PyInt_FromLong(field.value.asByte);

case GS_TYPE_SHORT:

return PyInt_FromLong(field.value.asShort);

case GS_TYPE_GEOMETRY:

return convertStrToObj(field.value.asGeometry);

case GS_TYPE_INTEGER_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asIntegerArray.size;

arrayPtr = (void*) field.value.asIntegerArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asInteger;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyInt_FromLong(*((int32_t *)arrayPtr + i)));

}

return list;

case GS_TYPE_STRING_ARRAY:

GSChar** arrString;

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asStringArray.size;

arrString = (GSChar**) field.value.asStringArray.elements;

%#else

listSize = field.value.asArray.length;

arrString = (GSChar**) field.value.asArray.elements.asString;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, convertStrToObj(arrString[i]));

}

return list;

case GS_TYPE_BOOL_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asBoolArray.size;

arrayPtr = (void*) field.value.asBoolArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asBool;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyBool_FromLong(*((bool *)arrayPtr + i)));

}

return list;

case GS_TYPE_BYTE_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asByteArray.size;

arrayPtr = (void*) field.value.asByteArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asByte;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyInt_FromLong(*((int8_t *)arrayPtr + i)));

}

return list;

case GS_TYPE_SHORT_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asShortArray.size;

arrayPtr = (void*) field.value.asShortArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asShort;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyInt_FromLong(*((int16_t *)arrayPtr + i)));

}

return list;

case GS_TYPE_LONG_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asLongArray.size;

arrayPtr = (void*) field.value.asLongArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asLong;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyLong_FromLong(*((int64_t *)arrayPtr + i)));

}

return list;

case GS_TYPE_FLOAT_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asFloatArray.size;

arrayPtr = (void*) field.value.asFloatArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asFloat;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyFloat_FromDouble(static_cast<double>(*((float *)arrayPtr + i))));

}

return list;

case GS_TYPE_DOUBLE_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asDoubleArray.size;

arrayPtr = (void*) field.value.asDoubleArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asDouble;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, PyFloat_FromDouble(*((double *)arrayPtr + i)));

}

return list;

case GS_TYPE_TIMESTAMP_ARRAY:

%#if GS_COMPATIBILITY_VALUE_1_1_106

listSize = field.value.asTimestampArray.size;

arrayPtr = (void*) field.value.asTimestampArray.elements;

%#else

listSize = field.value.asArray.length;

arrayPtr = (void*) field.value.asArray.elements.asTimestamp;

%#endif

list = PyList_New(listSize);

for (i = 0; i < listSize; i++) {

PyList_SetItem(list, i, convertTimestampToObject(((GSTimestamp *)arrayPtr + i), timestamp_to_float));

}

return list;

default:

return NULL;

}

return NULL;

}

}

%fragment("convertObjectToGSTimestamp", "header", fragment = "convertObjectToFloat") {

static bool convertObjectToGSTimestamp(PyObject* value, GSTimestamp* timestamp) {

int year, month, day, hour, minute, second, milliSecond, microSecond;

size_t size = 0;

int res;

char* v = 0;

bool vbool;

int alloc;

char s[30];

GSBool retConvertTimestamp;

if (PyBool_Check(value)) {

return false;

}

if (!PyDateTimeAPI) {

PyDateTime_IMPORT;

}

float floatTimestamp;

double utcTimestamp;

if (PyDateTime_Check(value)) {

// Input is Python utc datetime object

year = PyDateTime_GET_YEAR(value);

month = PyDateTime_GET_MONTH(value);

day = PyDateTime_GET_DAY(value);

hour = PyDateTime_DATE_GET_HOUR(value);

minute = PyDateTime_DATE_GET_MINUTE(value);

second = PyDateTime_DATE_GET_SECOND(value);

milliSecond = PyDateTime_DATE_GET_MICROSECOND(value)/1000;

sprintf(s, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", year, month, day, hour, minute, second, milliSecond);

retConvertTimestamp = gsParseTime(s, timestamp);

if (retConvertTimestamp == GS_FALSE) {

return false;

}

return true;

} else if (checkPyObjIsStr(value)) {

// Input is datetime string: ex

res = SWIG_AsCharPtrAndSize(value, &v, &size, &alloc);

if (!SWIG_IsOK(res)) {

return false;

}

// error when string len is too short

if (strlen(v) < 19) {

if (alloc != SWIG_OLDOBJ) {

free(v);

}

return false;

}

// this is for convert python's string datetime (YYYY-MM-DDTHH:mm:ss:sssZ)

// to griddb's string datetime (YYYY-MM-DDTHH:mm:ss.sssZ)

v[19] = '.';

//Date format is YYYY-MM-DDTHH:mm:ss.sssZ

retConvertTimestamp = gsParseTime(v, timestamp);

if (alloc != SWIG_OLDOBJ) {

free(v);

}

return (retConvertTimestamp == GS_TRUE);

} else if (PyFloat_Check(value)) {

// Input is python utc timestamp

//utcTimestamp = PyFloat_AsDouble(value);

vbool = convertObjectToDouble(value, &utcTimestamp);

if (!vbool) {

return false;

}

*timestamp = utcTimestamp * 1000;

if (utcTimestamp > UTC_TIMESTAMP_MAX) {

return false;

}

return true;

} else if (PyLong_Check(value)) {

utcTimestamp = PyLong_AsLong(value);

if (utcTimestamp > UTC_TIMESTAMP_MAX) {

return false;

}

*timestamp = utcTimestamp * 1000;

return true;

} else {

// Invalid input

return false;

}

}

}

%fragment("convertObjectToBool", "header", fragment = "SWIG_AsVal_bool", fragment = "SWIG_AsVal_int") {

static bool convertObjectToBool(PyObject* value, bool* boolValPtr) {

int checkConvert = 0;

if (PyInt_Check(value)) {

//input can be integer

int intVal ;

checkConvert = SWIG_AsVal_int(value, &intVal);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

*boolValPtr = (intVal != 0);

return true;

} else {

//input is boolean

checkConvert = SWIG_AsVal_bool(value, boolValPtr);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

return true;

}

}

}

%fragment("convertObjectToDouble", "header") {

static bool convertObjectToDouble(PyObject* value, double* floatValPtr) {

int checkConvert = 0;

if (PyBool_Check(value)) {

return false;

}

if (PyInt_Check(value)) {

//input can be integer

long int intVal;

checkConvert = SWIG_AsVal_long(value, &intVal);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

*floatValPtr = intVal;

//When input value is integer, it should be between -9007199254740992(-2^53)/9007199254740992(2^53).

return (-9007199254740992 <= intVal && 9007199254740992 >= intVal);

} else {

//input is float

if (!PyFloat_Check(value)) {

return false;

}

*floatValPtr = PyFloat_AsDouble(value);

return true;

}

}

}

%fragment("convertObjectToFloat", "header") {

static bool convertObjectToFloat(PyObject* value, float* floatValPtr) {

int checkConvert = 0;

if (PyBool_Check(value)) {

return false;

}

if (PyInt_Check(value)) {

//input can be integer

long int intVal;

checkConvert = SWIG_AsVal_long(value, &intVal);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

*floatValPtr = intVal;

//When input value is integer, it should be between -16777216(-2^24)/16777216(2^24).

return (-16777216 <= intVal && 16777216 >= intVal);

} else {

//input is float

if (!PyFloat_Check(value)) {

return false;

}

*floatValPtr = PyFloat_AsDouble(value);

return true;

}

}

}

%fragment("convertObjectToBlob", "header", fragment = "checkPyObjIsStr") {

static bool convertObjectToBlob(PyObject* value, size_t* size, void** data) {

GSChar* blobData;

GSChar* tmpBlobData;

int res;

if (PyByteArray_Check(value)) {

*size = PyByteArray_Size(value);

if (*size > 0) {

blobData = (GSChar*) malloc(sizeof(GSChar) * (*size));

if (blobData == NULL) {

return false;

}

memset(blobData, 0x0, sizeof(GSChar) * (*size));

memcpy(blobData, PyByteArray_AsString(value), *size);

*data = (void*) blobData;

}

return true;

} else if (checkPyObjIsStr(value)) {

int alloc;

res = SWIG_AsCharPtrAndSize(value, &blobData, size, &alloc);

if (!SWIG_IsOK(res)) {

return false;

}

if (alloc == SWIG_OLDOBJ) {

//swig reuse old memory, this memory is used by swig

//we will create new and duplicate this memory

blobData = strdup(blobData);

}

//Ignore null character

*size = *size - 1;

*data = (void*) blobData;

return true;

}

return false;

}

}

%fragment("convertObjectToFieldWithType", "header", fragment = "SWIG_AsCharPtrAndSize",

fragment = "checkPyObjIsStr", fragment = "convertObjToStr", fragment = "convertObjectToDouble",

fragment = "convertObjectToGSTimestamp", fragment = "SWIG_AsVal_bool",

fragment = "convertObjectToBlob", fragment = "convertObjectToBool",

fragment = "convertObjectToFloat") {

static bool convertObjectToFieldWithType(griddb::Field &field, PyObject* value, GSType type) {

size_t size = 0;

int res;

char* v = 0;

bool vbool;

int alloc;

field.type = type;

if (value == Py_None) {

%#if GS_COMPATIBILITY_SUPPORT_3_5

field.type = GS_TYPE_NULL;

return true;

%#else

//Not support NULL

return false;

%#endif

}

GSChar *mydata;

void *blobData;

int year, month, day, hour, minute, second, milliSecond;

char s[30];

int checkConvert = 0;

GSBool retConvertTimestamp;

char* pyobjToStr;

char* buffer;

PyObject* objectsRepresentation;

int arraySize, i;

void* arrayPtr;

int tmpInt;

long double tmpLongDouble;

double tmpDouble; //support convert to double, double array

float tmpFloat; //support convert to float, float array

bool inBorderVal = false;

bool inRange = false;

switch(type) {

case (GS_TYPE_STRING):

if (!checkPyObjIsStr(value)) {

return false;

}

res = SWIG_AsCharPtrAndSize(value, &v, &size, &alloc);

if (!SWIG_IsOK(res)) {

return false;

}

if (alloc == SWIG_OLDOBJ) {

//swig reuse old memory, this memory is used by swig

//we will create new and duplicate this memory

v = strdup(v);

}

field.value.asString = v;

field.type = GS_TYPE_STRING;

break;

case (GS_TYPE_BOOL):

vbool = convertObjectToBool(value, (bool*) &field.value.asBool);

if (!vbool) {

return false;

}

break;

case (GS_TYPE_BYTE):

if (PyBool_Check(value)) {

return false;

}

checkConvert = SWIG_AsVal_int(value, &tmpInt);

if (!SWIG_IsOK(checkConvert) ||

tmpInt < std::numeric_limits<int8_t>::min() ||

tmpInt > std::numeric_limits<int8_t>::max()) {

return false;

}

field.value.asByte = (int8_t) tmpInt;

break;

case (GS_TYPE_SHORT):

if (PyBool_Check(value)) {

return false;

}

checkConvert = SWIG_AsVal_int(value, &tmpInt);

if (!SWIG_IsOK(checkConvert) ||

tmpInt < std::numeric_limits<int16_t>::min() ||

tmpInt > std::numeric_limits<int16_t>::max()) {

return false;

}

field.value.asShort = (int16_t) tmpInt;

break;

case (GS_TYPE_INTEGER):

if (PyBool_Check(value)) {

return false;

}

checkConvert = SWIG_AsVal_int(value, &field.value.asInteger);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

break;

case (GS_TYPE_LONG):

if (PyBool_Check(value)) {

return false;

}

checkConvert = SWIG_AsVal_long(value, &field.value.asLong);

if (!SWIG_IsOK(checkConvert)) {

return false;

}

//Because swig function above not check overflow of long type.

break;

case (GS_TYPE_FLOAT):

vbool = convertObjectToFloat(value, &tmpFloat);

if (!vbool) {

return false;

}

field.value.asFloat = tmpFloat;

break;

case (GS_TYPE_DOUBLE):

vbool = convertObjectToDouble(value, &tmpDouble);

if (!vbool) {

return false;

}

field.value.asDouble = tmpDouble;

break;

case (GS_TYPE_TIMESTAMP):

return convertObjectToGSTimestamp(value, &field.value.asTimestamp);

break;

case (GS_TYPE_BLOB):

vbool = convertObjectToBlob(value, &field.value.asBlob.size, (void**) &field.value.asBlob.data);

if (!vbool) {

return false;

}

break;

case (GS_TYPE_STRING_ARRAY):

GSChar** arrString;

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asStringArray.size = arraySize;

field.value.asStringArray.elements = (GSChar**) malloc(arraySize * sizeof(GSChar*));

if (field.value.asStringArray.elements == NULL) {

return false;

}

arrString = (GSChar**) field.value.asStringArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asString = (GSChar**) malloc(arraySize * sizeof(GSChar*));

if (field.value.asArray.elements.asString == NULL) {

return false;

}

arrString = (GSChar**) field.value.asArray.elements.asString;

%#endif

for (i = 0; i < arraySize; i++) {

if (!checkPyObjIsStr(PyList_GetItem(value, i))) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

for (int j = 0; j < field.value.asStringArray.size; j++) {

free(const_cast<GSChar*> (field.value.asStringArray.elements[j]));

}

free((void*) field.value.asStringArray.elements);

field.value.asStringArray.elements = NULL;

%#else

for (int j = 0; j < i; j++) {

free(const_cast<GSChar*> (field.value.asArray.elements.asString[j]));

}

free((void*) field.value.asArray.elements.asString);

field.value.asArray.elements.asString = NULL;

%#endif

return false;

}

res = SWIG_AsCharPtrAndSize(PyList_GetItem(value, i), (arrString + i), &size, &alloc);

if (!SWIG_IsOK(res)) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

for (int j = 0; j < field.value.asStringArray.size; j++) {

free(const_cast<GSChar*> (field.value.asStringArray.elements[j]));

}

free((void*) field.value.asStringArray.elements);

field.value.asStringArray.elements = NULL;

%#else

for (int j = 0; j < i; j++) {

free(const_cast<GSChar*> (field.value.asArray.elements.asString[j]));

}

free((void*) field.value.asArray.elements.asString);

field.value.asArray.elements.asString = NULL;

%#endif

return false;

}

if (alloc == SWIG_OLDOBJ) {

arrString[i] = strdup(arrString[i]);

}

}

break;

case (GS_TYPE_GEOMETRY):

if (!checkPyObjIsStr(value)) {

return false;

}

res = SWIG_AsCharPtrAndSize(value, &v, &size, &alloc);

if (!SWIG_IsOK(res)) {

return false;

}

if (alloc == SWIG_OLDOBJ) {

//swig reuse old memory, this memory is used by swig

//we will create new and duplicate this memory

v = strdup(v);

}

field.value.asGeometry = v;

break;

case (GS_TYPE_INTEGER_ARRAY):

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

arrayPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asIntegerArray.size = arraySize;

field.value.asIntegerArray.elements = (const int32_t *) malloc(arraySize * sizeof(int32_t));

if (field.value.asIntegerArray.elements == NULL) {

return false;

}

arrayPtr = (void*) field.value.asIntegerArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asInteger = (const int32_t *) malloc(arraySize * sizeof(int32_t));

if (field.value.asArray.elements.asInteger == NULL) {

return false;

}

arrayPtr = (void*) field.value.asArray.elements.asInteger;

%#endif

for (i = 0; i < arraySize; i++) {

vbool = PyBool_Check(PyList_GetItem(value, i));

checkConvert = SWIG_AsVal_int(PyList_GetItem(value, i), ((int32_t *)arrayPtr + i));

if (!SWIG_IsOK(checkConvert) || vbool) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

free((void*)field.value.asIntegerArray.elements);

field.value.asIntegerArray.elements = NULL;

%#else

free((void*)field.value.asArray.elements.asInteger);

field.value.asArray.elements.asInteger = NULL;

%#endif

return false;

}

}

break;

case GS_TYPE_BOOL_ARRAY:

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

arrayPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asBoolArray.size = arraySize;

field.value.asBoolArray.elements = (const GSBool *) malloc(arraySize * sizeof(GSBool));

if (field.value.asBoolArray.elements == NULL) {

return false;

}

arrayPtr = (void*) field.value.asBoolArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asBool = (const GSBool *) malloc(arraySize * sizeof(GSBool));

if (field.value.asArray.elements.asBool == NULL) {

return false;

}

arrayPtr = (void*) field.value.asArray.elements.asBool;

%#endif

for (i = 0; i < arraySize; i++) {

vbool = convertObjectToBool(PyList_GetItem(value, i), ((bool *)arrayPtr + i));

if (!vbool) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

free((void*)field.value.asBoolArray.elements);

field.value.asBoolArray.elements = NULL:

%#else

free((void*)field.value.asArray.elements.asBool);

field.value.asArray.elements.asBool = NULL;

%#endif

return false;

}

}

break;

case GS_TYPE_BYTE_ARRAY:

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

arrayPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asByteArray.size = arraySize;

field.value.asByteArray.elements = (const int8_t *) malloc(arraySize * sizeof(int8_t));

if (field.value.asByteArray.elements == NULL) {

return false;

}

arrayPtr = (void*) field.value.asByteArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asByte = (const int8_t *) malloc(arraySize * sizeof(int8_t));

if (field.value.asArray.elements.asByte == NULL) {

return false;

}

arrayPtr = (void*) field.value.asArray.elements.asByte;

%#endif

for (i = 0; i < arraySize; i++) {

vbool = PyBool_Check(PyList_GetItem(value, i));

checkConvert = SWIG_AsVal_int(PyList_GetItem(value, i), &tmpInt);

*(((int8_t*)arrayPtr + i)) = (int8_t)tmpInt;

if (vbool || !SWIG_IsOK(checkConvert) ||

tmpInt < std::numeric_limits<int8_t>::min() ||

tmpInt > std::numeric_limits<int8_t>::max()) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

free((void*)field.value.asByteArray.elements);

field.value.asByteArray.elements = NULL;

%#else

free((void*)field.value.asArray.elements.asByte);

field.value.asArray.elements.asByte = NULL;

%#endif

return false;

}

}

break;

case GS_TYPE_SHORT_ARRAY:

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

arrayPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asShortArray.size = arraySize;

field.value.asShortArray.elements = (const int16_t *) malloc(arraySize * sizeof(int16_t));

if (field.value.asShortArray.elements == NULL) {

return false;

}

arrayPtr = (void*) field.value.asShortArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asShort = (const int16_t *) malloc(arraySize * sizeof(int16_t));

if (field.value.asArray.elements.asShort == NULL) {

return false;

}

arrayPtr = (void*) field.value.asArray.elements.asShort;

%#endif

for (i = 0; i < arraySize; i++) {

vbool = PyBool_Check(PyList_GetItem(value, i));

checkConvert = SWIG_AsVal_int(PyList_GetItem(value, i), &tmpInt);

*(((int16_t*)arrayPtr + i)) = (int16_t)tmpInt;

if (vbool || !SWIG_IsOK(checkConvert) ||

tmpInt < std::numeric_limits<int16_t>::min() ||

tmpInt > std::numeric_limits<int16_t>::max()) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

free((void*)field.value.asShortArray.elements);

field.value.asShortArray.elements = NULL;

%#else

free((void*)field.value.asArray.elements.asShort);

field.value.asArray.elements.asShort = NULL;

%#endif

return false;

}

}

break;

case GS_TYPE_LONG_ARRAY:

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

arrayPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asLongArray.size = arraySize;

field.value.asLongArray.elements = (const int64_t *) malloc(arraySize * sizeof(int64_t));

if (field.value.asLongArray.elements == NULL) {

return false;

}

arrayPtr = (void*) field.value.asLongArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asLong = (const int64_t *) malloc(arraySize * sizeof(int64_t));

if (field.value.asArray.elements.asLong == NULL) {

return false;

}

arrayPtr = (void*) field.value.asArray.elements.asLong;

%#endif

for (i = 0; i < arraySize; i++) {

vbool = PyBool_Check(PyList_GetItem(value, i));

checkConvert = SWIG_AsVal_long(PyList_GetItem(value, i), ((int64_t *)arrayPtr + i));

if (!SWIG_IsOK(checkConvert) || vbool) {

%#if GS_COMPATIBILITY_VALUE_1_1_106

free((void*)field.value.asLongArray.elements);

field.value.asLongArray.elements = NULL;

%#else

free((void*)field.value.asArray.elements.asLong);

field.value.asArray.elements.asLong = NULL;

%#endif

return false;

}

}

break;

case GS_TYPE_FLOAT_ARRAY:

float* floatPtr;

if (!PyList_Check(value)) {

return false;

}

arraySize = (int)PyInt_AsLong(PyLong_FromSsize_t(PyList_Size(value)));

floatPtr = NULL;

%#if GS_COMPATIBILITY_VALUE_1_1_106

field.value.asFloatArray.size = arraySize;

field.value.asFloatArray.elements = (const float *) malloc(arraySize * sizeof(float));

if (field.value.asFloatArray.elements == NULL) {

return false;

}

floatPtr = (float*) field.value.asFloatArray.elements;

%#else

field.value.asArray.length = arraySize;

field.value.asArray.elements.asFloat = (const float *) malloc(arraySize * sizeof(float));

if (field.value.asArray.elements.asFloat == NULL) {

return false;

}

floatPtr = (float*) field.value.asArray.elements.asFloat;

%#endif