From 2987efc57256af282100ecc891051989e260c6cb Mon Sep 17 00:00:00 2001
From: Ralf Mueller <ralf.mueller@dkrz.de>
Date: Fri, 9 Aug 2019 16:12:52 +0200
Subject: [PATCH] updates for swig 4.0.0
---
interfaces/python/CdiLib.py | 1998 +++-
interfaces/python/cdilib_wrap.c | 18311 ++++++++++++++++++++----------
interfaces/python/testLib.py | 2 +-
interfaces/ruby/cdilib_wrap.c | 15435 +++++++++++++++++--------
interfaces/ruby/cdiobj_wrap.cpp | 13 +-
interfaces/ruby/testLib.rb | 2 +-
6 files changed, 24721 insertions(+), 11040 deletions(-)
diff --git a/interfaces/python/CdiLib.py b/interfaces/python/CdiLib.py
index 89f0f54d2..a329f8121 100644
--- a/interfaces/python/CdiLib.py
+++ b/interfaces/python/CdiLib.py
@@ -1,121 +1,185 @@
# This file was automatically generated by SWIG (http://www.swig.org).
-# Version 1.3.36
+# Version 4.0.0
#
-# Don't modify this file, modify the SWIG interface instead.
-# This file is compatible with both classic and new-style classes.
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+if _swig_python_version_info < (2, 7, 0):
+ raise RuntimeError('Python 2.7 or later required')
+
+# Import the low-level C/C++ module
+if __package__ or '.' in __name__:
+ from . import _CdiLib
+else:
+ import _CdiLib
-import _CdiLib
-import new
-new_instancemethod = new.instancemethod
try:
- _swig_property = property
-except NameError:
- pass # Python < 2.2 doesn't have 'property'.
-def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
- if (name == "thisown"): return self.this.own(value)
- if (name == "this"):
- if type(value).__name__ == 'PySwigObject':
+ import builtins as __builtin__
+except ImportError:
+ import __builtin__
+
+def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
+ if name == "thisown":
+ return self.this.own(value)
+ if name == "this":
+ if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
- method = class_type.__swig_setmethods__.get(name,None)
- if method: return method(self,value)
- if (not static) or hasattr(self,name):
- self.__dict__[name] = value
+ method = class_type.__swig_setmethods__.get(name, None)
+ if method:
+ return method(self, value)
+ if not static:
+ object.__setattr__(self, name, value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
-def _swig_setattr(self,class_type,name,value):
- return _swig_setattr_nondynamic(self,class_type,name,value,0)
-def _swig_getattr(self,class_type,name):
- if (name == "thisown"): return self.this.own()
- method = class_type.__swig_getmethods__.get(name,None)
- if method: return method(self)
- raise AttributeError,name
+def _swig_setattr(self, class_type, name, value):
+ return _swig_setattr_nondynamic(self, class_type, name, value, 0)
+
+
+def _swig_getattr(self, class_type, name):
+ if name == "thisown":
+ return self.this.own()
+ method = class_type.__swig_getmethods__.get(name, None)
+ if method:
+ return method(self)
+ raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
+
def _swig_repr(self):
- try: strthis = "proxy of " + self.this.__repr__()
- except: strthis = ""
+ try:
+ strthis = "proxy of " + self.this.__repr__()
+ except __builtin__.Exception:
+ strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
-import types
-try:
- _object = types.ObjectType
- _newclass = 1
-except AttributeError:
- class _object : pass
- _newclass = 0
-del types
+
+def _swig_setattr_nondynamic_instance_variable(set):
+ def set_instance_attr(self, name, value):
+ if name == "thisown":
+ self.this.own(value)
+ elif name == "this":
+ set(self, name, value)
+ elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+ set(self, name, value)
+ else:
+ raise AttributeError("You cannot add instance attributes to %s" % self)
+ return set_instance_attr
+def _swig_setattr_nondynamic_class_variable(set):
+ def set_class_attr(cls, name, value):
+ if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+ set(cls, name, value)
+ else:
+ raise AttributeError("You cannot add class attributes to %s" % cls)
+ return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+ """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+ def wrapper(cls):
+ return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+ return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+ """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+ __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+CDI_MAX_NAME = _CdiLib.CDI_MAX_NAME
CDI_UNDEFID = _CdiLib.CDI_UNDEFID
CDI_GLOBAL = _CdiLib.CDI_GLOBAL
CDI_BIGENDIAN = _CdiLib.CDI_BIGENDIAN
CDI_LITTLEENDIAN = _CdiLib.CDI_LITTLEENDIAN
+CDI_PDPENDIAN = _CdiLib.CDI_PDPENDIAN
+CDI_REAL = _CdiLib.CDI_REAL
+CDI_COMP = _CdiLib.CDI_COMP
+CDI_BOTH = _CdiLib.CDI_BOTH
CDI_NOERR = _CdiLib.CDI_NOERR
+CDI_EEOF = _CdiLib.CDI_EEOF
+CDI_ETMOF = _CdiLib.CDI_ETMOF
CDI_ESYSTEM = _CdiLib.CDI_ESYSTEM
CDI_EINVAL = _CdiLib.CDI_EINVAL
+CDI_EISDIR = _CdiLib.CDI_EISDIR
+CDI_EISEMPTY = _CdiLib.CDI_EISEMPTY
CDI_EUFTYPE = _CdiLib.CDI_EUFTYPE
CDI_ELIBNAVAIL = _CdiLib.CDI_ELIBNAVAIL
CDI_EUFSTRUCT = _CdiLib.CDI_EUFSTRUCT
CDI_EUNC4 = _CdiLib.CDI_EUNC4
-FILETYPE_GRB = _CdiLib.FILETYPE_GRB
-FILETYPE_GRB2 = _CdiLib.FILETYPE_GRB2
-FILETYPE_NC = _CdiLib.FILETYPE_NC
-FILETYPE_NC2 = _CdiLib.FILETYPE_NC2
-FILETYPE_NC4 = _CdiLib.FILETYPE_NC4
-FILETYPE_SRV = _CdiLib.FILETYPE_SRV
-FILETYPE_EXT = _CdiLib.FILETYPE_EXT
-FILETYPE_IEG = _CdiLib.FILETYPE_IEG
-COMPRESS_NONE = _CdiLib.COMPRESS_NONE
-COMPRESS_SZIP = _CdiLib.COMPRESS_SZIP
-COMPRESS_GZIP = _CdiLib.COMPRESS_GZIP
-COMPRESS_BZIP2 = _CdiLib.COMPRESS_BZIP2
-COMPRESS_ZIP = _CdiLib.COMPRESS_ZIP
-DATATYPE_PACK = _CdiLib.DATATYPE_PACK
-DATATYPE_PACK1 = _CdiLib.DATATYPE_PACK1
-DATATYPE_PACK2 = _CdiLib.DATATYPE_PACK2
-DATATYPE_PACK3 = _CdiLib.DATATYPE_PACK3
-DATATYPE_PACK4 = _CdiLib.DATATYPE_PACK4
-DATATYPE_PACK5 = _CdiLib.DATATYPE_PACK5
-DATATYPE_PACK6 = _CdiLib.DATATYPE_PACK6
-DATATYPE_PACK7 = _CdiLib.DATATYPE_PACK7
-DATATYPE_PACK8 = _CdiLib.DATATYPE_PACK8
-DATATYPE_PACK9 = _CdiLib.DATATYPE_PACK9
-DATATYPE_PACK10 = _CdiLib.DATATYPE_PACK10
-DATATYPE_PACK11 = _CdiLib.DATATYPE_PACK11
-DATATYPE_PACK12 = _CdiLib.DATATYPE_PACK12
-DATATYPE_PACK13 = _CdiLib.DATATYPE_PACK13
-DATATYPE_PACK14 = _CdiLib.DATATYPE_PACK14
-DATATYPE_PACK15 = _CdiLib.DATATYPE_PACK15
-DATATYPE_PACK16 = _CdiLib.DATATYPE_PACK16
-DATATYPE_PACK17 = _CdiLib.DATATYPE_PACK17
-DATATYPE_PACK18 = _CdiLib.DATATYPE_PACK18
-DATATYPE_PACK19 = _CdiLib.DATATYPE_PACK19
-DATATYPE_PACK20 = _CdiLib.DATATYPE_PACK20
-DATATYPE_PACK21 = _CdiLib.DATATYPE_PACK21
-DATATYPE_PACK22 = _CdiLib.DATATYPE_PACK22
-DATATYPE_PACK23 = _CdiLib.DATATYPE_PACK23
-DATATYPE_PACK24 = _CdiLib.DATATYPE_PACK24
-DATATYPE_PACK25 = _CdiLib.DATATYPE_PACK25
-DATATYPE_PACK26 = _CdiLib.DATATYPE_PACK26
-DATATYPE_PACK27 = _CdiLib.DATATYPE_PACK27
-DATATYPE_PACK28 = _CdiLib.DATATYPE_PACK28
-DATATYPE_PACK29 = _CdiLib.DATATYPE_PACK29
-DATATYPE_PACK30 = _CdiLib.DATATYPE_PACK30
-DATATYPE_PACK31 = _CdiLib.DATATYPE_PACK31
-DATATYPE_PACK32 = _CdiLib.DATATYPE_PACK32
-DATATYPE_FLT32 = _CdiLib.DATATYPE_FLT32
-DATATYPE_FLT64 = _CdiLib.DATATYPE_FLT64
-DATATYPE_INT8 = _CdiLib.DATATYPE_INT8
-DATATYPE_INT16 = _CdiLib.DATATYPE_INT16
-DATATYPE_INT32 = _CdiLib.DATATYPE_INT32
-DATATYPE_UINT8 = _CdiLib.DATATYPE_UINT8
-DATATYPE_UINT16 = _CdiLib.DATATYPE_UINT16
-DATATYPE_UINT32 = _CdiLib.DATATYPE_UINT32
-DATATYPE_INT = _CdiLib.DATATYPE_INT
-DATATYPE_FLT = _CdiLib.DATATYPE_FLT
-DATATYPE_TXT = _CdiLib.DATATYPE_TXT
+CDI_EDIMSIZE = _CdiLib.CDI_EDIMSIZE
+CDI_ELIMIT = _CdiLib.CDI_ELIMIT
+CDI_FILETYPE_GRB = _CdiLib.CDI_FILETYPE_GRB
+CDI_FILETYPE_GRB2 = _CdiLib.CDI_FILETYPE_GRB2
+CDI_FILETYPE_NC = _CdiLib.CDI_FILETYPE_NC
+CDI_FILETYPE_NC2 = _CdiLib.CDI_FILETYPE_NC2
+CDI_FILETYPE_NC4 = _CdiLib.CDI_FILETYPE_NC4
+CDI_FILETYPE_NC4C = _CdiLib.CDI_FILETYPE_NC4C
+CDI_FILETYPE_NC5 = _CdiLib.CDI_FILETYPE_NC5
+CDI_FILETYPE_SRV = _CdiLib.CDI_FILETYPE_SRV
+CDI_FILETYPE_EXT = _CdiLib.CDI_FILETYPE_EXT
+CDI_FILETYPE_IEG = _CdiLib.CDI_FILETYPE_IEG
+CDI_COMPRESS_NONE = _CdiLib.CDI_COMPRESS_NONE
+CDI_COMPRESS_SZIP = _CdiLib.CDI_COMPRESS_SZIP
+CDI_COMPRESS_AEC = _CdiLib.CDI_COMPRESS_AEC
+CDI_COMPRESS_ZIP = _CdiLib.CDI_COMPRESS_ZIP
+CDI_COMPRESS_JPEG = _CdiLib.CDI_COMPRESS_JPEG
+CDI_DATATYPE_PACK = _CdiLib.CDI_DATATYPE_PACK
+CDI_DATATYPE_PACK1 = _CdiLib.CDI_DATATYPE_PACK1
+CDI_DATATYPE_PACK2 = _CdiLib.CDI_DATATYPE_PACK2
+CDI_DATATYPE_PACK3 = _CdiLib.CDI_DATATYPE_PACK3
+CDI_DATATYPE_PACK4 = _CdiLib.CDI_DATATYPE_PACK4
+CDI_DATATYPE_PACK5 = _CdiLib.CDI_DATATYPE_PACK5
+CDI_DATATYPE_PACK6 = _CdiLib.CDI_DATATYPE_PACK6
+CDI_DATATYPE_PACK7 = _CdiLib.CDI_DATATYPE_PACK7
+CDI_DATATYPE_PACK8 = _CdiLib.CDI_DATATYPE_PACK8
+CDI_DATATYPE_PACK9 = _CdiLib.CDI_DATATYPE_PACK9
+CDI_DATATYPE_PACK10 = _CdiLib.CDI_DATATYPE_PACK10
+CDI_DATATYPE_PACK11 = _CdiLib.CDI_DATATYPE_PACK11
+CDI_DATATYPE_PACK12 = _CdiLib.CDI_DATATYPE_PACK12
+CDI_DATATYPE_PACK13 = _CdiLib.CDI_DATATYPE_PACK13
+CDI_DATATYPE_PACK14 = _CdiLib.CDI_DATATYPE_PACK14
+CDI_DATATYPE_PACK15 = _CdiLib.CDI_DATATYPE_PACK15
+CDI_DATATYPE_PACK16 = _CdiLib.CDI_DATATYPE_PACK16
+CDI_DATATYPE_PACK17 = _CdiLib.CDI_DATATYPE_PACK17
+CDI_DATATYPE_PACK18 = _CdiLib.CDI_DATATYPE_PACK18
+CDI_DATATYPE_PACK19 = _CdiLib.CDI_DATATYPE_PACK19
+CDI_DATATYPE_PACK20 = _CdiLib.CDI_DATATYPE_PACK20
+CDI_DATATYPE_PACK21 = _CdiLib.CDI_DATATYPE_PACK21
+CDI_DATATYPE_PACK22 = _CdiLib.CDI_DATATYPE_PACK22
+CDI_DATATYPE_PACK23 = _CdiLib.CDI_DATATYPE_PACK23
+CDI_DATATYPE_PACK24 = _CdiLib.CDI_DATATYPE_PACK24
+CDI_DATATYPE_PACK25 = _CdiLib.CDI_DATATYPE_PACK25
+CDI_DATATYPE_PACK26 = _CdiLib.CDI_DATATYPE_PACK26
+CDI_DATATYPE_PACK27 = _CdiLib.CDI_DATATYPE_PACK27
+CDI_DATATYPE_PACK28 = _CdiLib.CDI_DATATYPE_PACK28
+CDI_DATATYPE_PACK29 = _CdiLib.CDI_DATATYPE_PACK29
+CDI_DATATYPE_PACK30 = _CdiLib.CDI_DATATYPE_PACK30
+CDI_DATATYPE_PACK31 = _CdiLib.CDI_DATATYPE_PACK31
+CDI_DATATYPE_PACK32 = _CdiLib.CDI_DATATYPE_PACK32
+CDI_DATATYPE_CPX32 = _CdiLib.CDI_DATATYPE_CPX32
+CDI_DATATYPE_CPX64 = _CdiLib.CDI_DATATYPE_CPX64
+CDI_DATATYPE_FLT32 = _CdiLib.CDI_DATATYPE_FLT32
+CDI_DATATYPE_FLT64 = _CdiLib.CDI_DATATYPE_FLT64
+CDI_DATATYPE_INT8 = _CdiLib.CDI_DATATYPE_INT8
+CDI_DATATYPE_INT16 = _CdiLib.CDI_DATATYPE_INT16
+CDI_DATATYPE_INT32 = _CdiLib.CDI_DATATYPE_INT32
+CDI_DATATYPE_UINT8 = _CdiLib.CDI_DATATYPE_UINT8
+CDI_DATATYPE_UINT16 = _CdiLib.CDI_DATATYPE_UINT16
+CDI_DATATYPE_UINT32 = _CdiLib.CDI_DATATYPE_UINT32
+CDI_DATATYPE_INT = _CdiLib.CDI_DATATYPE_INT
+CDI_DATATYPE_FLT = _CdiLib.CDI_DATATYPE_FLT
+CDI_DATATYPE_TXT = _CdiLib.CDI_DATATYPE_TXT
+CDI_DATATYPE_CPX = _CdiLib.CDI_DATATYPE_CPX
+CDI_DATATYPE_UCHAR = _CdiLib.CDI_DATATYPE_UCHAR
+CDI_DATATYPE_LONG = _CdiLib.CDI_DATATYPE_LONG
+CDI_DATATYPE_UINT = _CdiLib.CDI_DATATYPE_UINT
+CDI_CHUNK_AUTO = _CdiLib.CDI_CHUNK_AUTO
+CDI_CHUNK_GRID = _CdiLib.CDI_CHUNK_GRID
+CDI_CHUNK_LINES = _CdiLib.CDI_CHUNK_LINES
GRID_GENERIC = _CdiLib.GRID_GENERIC
GRID_GAUSSIAN = _CdiLib.GRID_GAUSSIAN
GRID_GAUSSIAN_REDUCED = _CdiLib.GRID_GAUSSIAN_REDUCED
@@ -126,10 +190,13 @@ GRID_GME = _CdiLib.GRID_GME
GRID_TRAJECTORY = _CdiLib.GRID_TRAJECTORY
GRID_UNSTRUCTURED = _CdiLib.GRID_UNSTRUCTURED
GRID_CURVILINEAR = _CdiLib.GRID_CURVILINEAR
-GRID_LCC = _CdiLib.GRID_LCC
-GRID_LCC2 = _CdiLib.GRID_LCC2
-GRID_LAEA = _CdiLib.GRID_LAEA
-GRID_SINUSOIDAL = _CdiLib.GRID_SINUSOIDAL
+GRID_PROJECTION = _CdiLib.GRID_PROJECTION
+GRID_CHARXY = _CdiLib.GRID_CHARXY
+CDI_PROJ_RLL = _CdiLib.CDI_PROJ_RLL
+CDI_PROJ_LCC = _CdiLib.CDI_PROJ_LCC
+CDI_PROJ_LAEA = _CdiLib.CDI_PROJ_LAEA
+CDI_PROJ_SINU = _CdiLib.CDI_PROJ_SINU
+CDI_PROJ_STERE = _CdiLib.CDI_PROJ_STERE
ZAXIS_SURFACE = _CdiLib.ZAXIS_SURFACE
ZAXIS_GENERIC = _CdiLib.ZAXIS_GENERIC
ZAXIS_HYBRID = _CdiLib.ZAXIS_HYBRID
@@ -143,320 +210,1459 @@ ZAXIS_TRAJECTORY = _CdiLib.ZAXIS_TRAJECTORY
ZAXIS_ALTITUDE = _CdiLib.ZAXIS_ALTITUDE
ZAXIS_SIGMA = _CdiLib.ZAXIS_SIGMA
ZAXIS_MEANSEA = _CdiLib.ZAXIS_MEANSEA
-TAXIS_ABSOLUTE = _CdiLib.TAXIS_ABSOLUTE
-TAXIS_RELATIVE = _CdiLib.TAXIS_RELATIVE
+ZAXIS_TOA = _CdiLib.ZAXIS_TOA
+ZAXIS_SEA_BOTTOM = _CdiLib.ZAXIS_SEA_BOTTOM
+ZAXIS_ATMOSPHERE = _CdiLib.ZAXIS_ATMOSPHERE
+ZAXIS_CLOUD_BASE = _CdiLib.ZAXIS_CLOUD_BASE
+ZAXIS_CLOUD_TOP = _CdiLib.ZAXIS_CLOUD_TOP
+ZAXIS_ISOTHERM_ZERO = _CdiLib.ZAXIS_ISOTHERM_ZERO
+ZAXIS_SNOW = _CdiLib.ZAXIS_SNOW
+ZAXIS_LAKE_BOTTOM = _CdiLib.ZAXIS_LAKE_BOTTOM
+ZAXIS_SEDIMENT_BOTTOM = _CdiLib.ZAXIS_SEDIMENT_BOTTOM
+ZAXIS_SEDIMENT_BOTTOM_TA = _CdiLib.ZAXIS_SEDIMENT_BOTTOM_TA
+ZAXIS_SEDIMENT_BOTTOM_TW = _CdiLib.ZAXIS_SEDIMENT_BOTTOM_TW
+ZAXIS_MIX_LAYER = _CdiLib.ZAXIS_MIX_LAYER
+ZAXIS_REFERENCE = _CdiLib.ZAXIS_REFERENCE
+ZAXIS_CHAR = _CdiLib.ZAXIS_CHAR
+SUBTYPE_TILES = _CdiLib.SUBTYPE_TILES
+MAX_KV_PAIRS_MATCH = _CdiLib.MAX_KV_PAIRS_MATCH
+class subtype_query_t(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ nAND = property(_CdiLib.subtype_query_t_nAND_get, _CdiLib.subtype_query_t_nAND_set)
+ key_value_pairs = property(_CdiLib.subtype_query_t_key_value_pairs_get, _CdiLib.subtype_query_t_key_value_pairs_set)
+
+ def __init__(self):
+ _CdiLib.subtype_query_t_swiginit(self, _CdiLib.new_subtype_query_t())
+ __swig_destroy__ = _CdiLib.delete_subtype_query_t
+
+# Register subtype_query_t in _CdiLib:
+_CdiLib.subtype_query_t_swigregister(subtype_query_t)
+
TIME_CONSTANT = _CdiLib.TIME_CONSTANT
+TIME_VARYING = _CdiLib.TIME_VARYING
TIME_VARIABLE = _CdiLib.TIME_VARIABLE
+TSTEP_INSTANT = _CdiLib.TSTEP_INSTANT
+TSTEP_AVG = _CdiLib.TSTEP_AVG
+TSTEP_ACCUM = _CdiLib.TSTEP_ACCUM
+TSTEP_MAX = _CdiLib.TSTEP_MAX
+TSTEP_MIN = _CdiLib.TSTEP_MIN
+TSTEP_DIFF = _CdiLib.TSTEP_DIFF
+TSTEP_RMS = _CdiLib.TSTEP_RMS
+TSTEP_SD = _CdiLib.TSTEP_SD
+TSTEP_COV = _CdiLib.TSTEP_COV
+TSTEP_RATIO = _CdiLib.TSTEP_RATIO
+TSTEP_SUM = _CdiLib.TSTEP_SUM
+TSTEP_RANGE = _CdiLib.TSTEP_RANGE
+TSTEP_INSTANT2 = _CdiLib.TSTEP_INSTANT2
+TSTEP_INSTANT3 = _CdiLib.TSTEP_INSTANT3
+TAXIS_ABSOLUTE = _CdiLib.TAXIS_ABSOLUTE
+TAXIS_RELATIVE = _CdiLib.TAXIS_RELATIVE
+TAXIS_FORECAST = _CdiLib.TAXIS_FORECAST
TUNIT_SECOND = _CdiLib.TUNIT_SECOND
TUNIT_MINUTE = _CdiLib.TUNIT_MINUTE
+TUNIT_QUARTER = _CdiLib.TUNIT_QUARTER
+TUNIT_30MINUTES = _CdiLib.TUNIT_30MINUTES
TUNIT_HOUR = _CdiLib.TUNIT_HOUR
+TUNIT_3HOURS = _CdiLib.TUNIT_3HOURS
+TUNIT_6HOURS = _CdiLib.TUNIT_6HOURS
+TUNIT_12HOURS = _CdiLib.TUNIT_12HOURS
TUNIT_DAY = _CdiLib.TUNIT_DAY
TUNIT_MONTH = _CdiLib.TUNIT_MONTH
TUNIT_YEAR = _CdiLib.TUNIT_YEAR
-TUNIT_QUARTER = _CdiLib.TUNIT_QUARTER
CALENDAR_STANDARD = _CdiLib.CALENDAR_STANDARD
+CALENDAR_GREGORIAN = _CdiLib.CALENDAR_GREGORIAN
CALENDAR_PROLEPTIC = _CdiLib.CALENDAR_PROLEPTIC
CALENDAR_360DAYS = _CdiLib.CALENDAR_360DAYS
CALENDAR_365DAYS = _CdiLib.CALENDAR_365DAYS
CALENDAR_366DAYS = _CdiLib.CALENDAR_366DAYS
CALENDAR_NONE = _CdiLib.CALENDAR_NONE
-cdiStringError = _CdiLib.cdiStringError
-cdiDebug = _CdiLib.cdiDebug
-cdiLibraryVersion = _CdiLib.cdiLibraryVersion
-cdiPrintVersion = _CdiLib.cdiPrintVersion
-cdiDefMissval = _CdiLib.cdiDefMissval
-cdiInqMissval = _CdiLib.cdiInqMissval
-cdiDefGlobal = _CdiLib.cdiDefGlobal
-streamOpenRead = _CdiLib.streamOpenRead
-streamOpenWrite = _CdiLib.streamOpenWrite
-streamOpenAppend = _CdiLib.streamOpenAppend
-streamClose = _CdiLib.streamClose
-streamSync = _CdiLib.streamSync
-streamDefVlist = _CdiLib.streamDefVlist
-streamInqVlist = _CdiLib.streamInqVlist
-streamInqFiletype = _CdiLib.streamInqFiletype
-streamDefByteorder = _CdiLib.streamDefByteorder
-streamInqByteorder = _CdiLib.streamInqByteorder
-streamDefZtype = _CdiLib.streamDefZtype
-streamDefZlevel = _CdiLib.streamDefZlevel
-streamInqZtype = _CdiLib.streamInqZtype
-streamInqZlevel = _CdiLib.streamInqZlevel
-streamDefTimestep = _CdiLib.streamDefTimestep
-streamInqTimestep = _CdiLib.streamInqTimestep
-streamFilename = _CdiLib.streamFilename
-streamFilesuffix = _CdiLib.streamFilesuffix
-streamNtsteps = _CdiLib.streamNtsteps
-streamNvals = _CdiLib.streamNvals
-streamReadVar = _CdiLib.streamReadVar
-streamWriteVar = _CdiLib.streamWriteVar
-streamReadVarSlice = _CdiLib.streamReadVarSlice
-streamWriteVarSlice = _CdiLib.streamWriteVarSlice
-streamInqRecord = _CdiLib.streamInqRecord
-streamDefRecord = _CdiLib.streamDefRecord
-streamReadRecord = _CdiLib.streamReadRecord
-streamWriteRecord = _CdiLib.streamWriteRecord
-streamCopyRecord = _CdiLib.streamCopyRecord
-streamInqGinfo = _CdiLib.streamInqGinfo
-vlistCreate = _CdiLib.vlistCreate
-vlistDestroy = _CdiLib.vlistDestroy
-vlistDuplicate = _CdiLib.vlistDuplicate
-vlistCopy = _CdiLib.vlistCopy
-vlistCopyFlag = _CdiLib.vlistCopyFlag
-vlistClearFlag = _CdiLib.vlistClearFlag
-vlistCat = _CdiLib.vlistCat
-vlistMerge = _CdiLib.vlistMerge
-vlistPrint = _CdiLib.vlistPrint
-vlistNvars = _CdiLib.vlistNvars
-vlistNgrids = _CdiLib.vlistNgrids
-vlistNzaxis = _CdiLib.vlistNzaxis
-vlistDefNtsteps = _CdiLib.vlistDefNtsteps
-vlistNtsteps = _CdiLib.vlistNtsteps
-vlistGridsizeMax = _CdiLib.vlistGridsizeMax
-vlistGrid = _CdiLib.vlistGrid
-vlistGridIndex = _CdiLib.vlistGridIndex
-vlistChangeGridIndex = _CdiLib.vlistChangeGridIndex
-vlistChangeGrid = _CdiLib.vlistChangeGrid
-vlistZaxis = _CdiLib.vlistZaxis
-vlistZaxisIndex = _CdiLib.vlistZaxisIndex
-vlistChangeZaxisIndex = _CdiLib.vlistChangeZaxisIndex
-vlistChangeZaxis = _CdiLib.vlistChangeZaxis
-vlistNrecs = _CdiLib.vlistNrecs
-vlistDefTaxis = _CdiLib.vlistDefTaxis
-vlistInqTaxis = _CdiLib.vlistInqTaxis
-vlistDefTable = _CdiLib.vlistDefTable
-vlistInqTable = _CdiLib.vlistInqTable
-vlistDefInstitut = _CdiLib.vlistDefInstitut
-vlistInqInstitut = _CdiLib.vlistInqInstitut
-vlistDefModel = _CdiLib.vlistDefModel
-vlistInqModel = _CdiLib.vlistInqModel
-vlistDefVar = _CdiLib.vlistDefVar
-vlistChangeVarGrid = _CdiLib.vlistChangeVarGrid
-vlistChangeVarZaxis = _CdiLib.vlistChangeVarZaxis
-vlistInqVar = _CdiLib.vlistInqVar
-vlistInqVarGrid = _CdiLib.vlistInqVarGrid
-vlistInqVarZaxis = _CdiLib.vlistInqVarZaxis
-vlistInqVarTime = _CdiLib.vlistInqVarTime
-vlistDefVarZtype = _CdiLib.vlistDefVarZtype
-vlistInqVarZtype = _CdiLib.vlistInqVarZtype
-vlistDefVarZlevel = _CdiLib.vlistDefVarZlevel
-vlistInqVarZlevel = _CdiLib.vlistInqVarZlevel
-vlistDefVarCode = _CdiLib.vlistDefVarCode
-vlistInqVarCode = _CdiLib.vlistInqVarCode
-vlistDefVarDatatype = _CdiLib.vlistDefVarDatatype
-vlistInqVarDatatype = _CdiLib.vlistInqVarDatatype
-vlistDefVarInstitut = _CdiLib.vlistDefVarInstitut
-vlistInqVarInstitut = _CdiLib.vlistInqVarInstitut
-vlistDefVarModel = _CdiLib.vlistDefVarModel
-vlistInqVarModel = _CdiLib.vlistInqVarModel
-vlistDefVarTable = _CdiLib.vlistDefVarTable
-vlistInqVarTable = _CdiLib.vlistInqVarTable
-vlistDefVarName = _CdiLib.vlistDefVarName
-vlistInqVarName = _CdiLib.vlistInqVarName
-vlistDefVarLongname = _CdiLib.vlistDefVarLongname
-vlistDefVarStdname = _CdiLib.vlistDefVarStdname
-vlistInqVarLongname = _CdiLib.vlistInqVarLongname
-vlistInqVarStdname = _CdiLib.vlistInqVarStdname
-vlistDefVarUnits = _CdiLib.vlistDefVarUnits
-vlistInqVarUnits = _CdiLib.vlistInqVarUnits
-vlistDefVarMissval = _CdiLib.vlistDefVarMissval
-vlistInqVarMissval = _CdiLib.vlistInqVarMissval
-vlistDefVarScalefactor = _CdiLib.vlistDefVarScalefactor
-vlistInqVarScalefactor = _CdiLib.vlistInqVarScalefactor
-vlistDefVarAddoffset = _CdiLib.vlistDefVarAddoffset
-vlistInqVarAddoffset = _CdiLib.vlistInqVarAddoffset
-vlistDefVarTimave = _CdiLib.vlistDefVarTimave
-vlistInqVarTimave = _CdiLib.vlistInqVarTimave
-vlistDefVarTimaccu = _CdiLib.vlistDefVarTimaccu
-vlistInqVarTimaccu = _CdiLib.vlistInqVarTimaccu
-vlistInqVarSize = _CdiLib.vlistInqVarSize
-vlistInqVarID = _CdiLib.vlistInqVarID
-vlistDefIndex = _CdiLib.vlistDefIndex
-vlistInqIndex = _CdiLib.vlistInqIndex
-vlistDefFlag = _CdiLib.vlistDefFlag
-vlistInqFlag = _CdiLib.vlistInqFlag
-vlistFindVar = _CdiLib.vlistFindVar
-vlistFindLevel = _CdiLib.vlistFindLevel
-vlistMergedVar = _CdiLib.vlistMergedVar
-vlistMergedLevel = _CdiLib.vlistMergedLevel
-vlistInqNatts = _CdiLib.vlistInqNatts
-vlistInqAtt = _CdiLib.vlistInqAtt
-vlistDelAtt = _CdiLib.vlistDelAtt
-vlistDefAttInt = _CdiLib.vlistDefAttInt
-vlistDefAttFlt = _CdiLib.vlistDefAttFlt
-vlistDefAttTxt = _CdiLib.vlistDefAttTxt
-vlistInqAttInt = _CdiLib.vlistInqAttInt
-vlistInqAttFlt = _CdiLib.vlistInqAttFlt
-vlistInqAttTxt = _CdiLib.vlistInqAttTxt
-gridName = _CdiLib.gridName
-gridNamePtr = _CdiLib.gridNamePtr
-gridCompress = _CdiLib.gridCompress
-gridDefMask = _CdiLib.gridDefMask
-gridInqMask = _CdiLib.gridInqMask
-gridPrint = _CdiLib.gridPrint
-gridSize = _CdiLib.gridSize
-gridCreate = _CdiLib.gridCreate
-gridDestroy = _CdiLib.gridDestroy
-gridDuplicate = _CdiLib.gridDuplicate
-gridInqType = _CdiLib.gridInqType
-gridInqSize = _CdiLib.gridInqSize
-gridDefXsize = _CdiLib.gridDefXsize
-gridInqXsize = _CdiLib.gridInqXsize
-gridDefYsize = _CdiLib.gridDefYsize
-gridInqYsize = _CdiLib.gridInqYsize
-gridDefXvals = _CdiLib.gridDefXvals
-gridInqXvals = _CdiLib.gridInqXvals
-gridDefYvals = _CdiLib.gridDefYvals
-gridInqYvals = _CdiLib.gridInqYvals
-gridDefXname = _CdiLib.gridDefXname
-gridDefXlongname = _CdiLib.gridDefXlongname
-gridDefXunits = _CdiLib.gridDefXunits
-gridDefYname = _CdiLib.gridDefYname
-gridDefYlongname = _CdiLib.gridDefYlongname
-gridDefYunits = _CdiLib.gridDefYunits
-gridInqXname = _CdiLib.gridInqXname
-gridInqXlongname = _CdiLib.gridInqXlongname
-gridInqXstdname = _CdiLib.gridInqXstdname
-gridInqXunits = _CdiLib.gridInqXunits
-gridInqYname = _CdiLib.gridInqYname
-gridInqYlongname = _CdiLib.gridInqYlongname
-gridInqYstdname = _CdiLib.gridInqYstdname
-gridInqYunits = _CdiLib.gridInqYunits
-gridDefDatatype = _CdiLib.gridDefDatatype
-gridInqDatatype = _CdiLib.gridInqDatatype
-gridInqXval = _CdiLib.gridInqXval
-gridInqYval = _CdiLib.gridInqYval
-gridInqXinc = _CdiLib.gridInqXinc
-gridInqYinc = _CdiLib.gridInqYinc
-gridIsCircular = _CdiLib.gridIsCircular
-gridIsRotated = _CdiLib.gridIsRotated
-gridInqXpole = _CdiLib.gridInqXpole
-gridDefXpole = _CdiLib.gridDefXpole
-gridInqYpole = _CdiLib.gridInqYpole
-gridDefYpole = _CdiLib.gridDefYpole
-gridInqAngle = _CdiLib.gridInqAngle
-gridDefAngle = _CdiLib.gridDefAngle
-gridDefTrunc = _CdiLib.gridDefTrunc
-gridInqTrunc = _CdiLib.gridInqTrunc
-gridInqGMEnd = _CdiLib.gridInqGMEnd
-gridDefGMEnd = _CdiLib.gridDefGMEnd
-gridInqGMEni = _CdiLib.gridInqGMEni
-gridDefGMEni = _CdiLib.gridDefGMEni
-gridInqGMEni2 = _CdiLib.gridInqGMEni2
-gridDefGMEni2 = _CdiLib.gridDefGMEni2
-gridInqGMEni3 = _CdiLib.gridInqGMEni3
-gridDefGMEni3 = _CdiLib.gridDefGMEni3
-gridDefLCC = _CdiLib.gridDefLCC
-gridInqLCC = _CdiLib.gridInqLCC
-gridDefLcc2 = _CdiLib.gridDefLcc2
-gridInqLcc2 = _CdiLib.gridInqLcc2
-gridDefLaea = _CdiLib.gridDefLaea
-gridInqLaea = _CdiLib.gridInqLaea
-gridDefArea = _CdiLib.gridDefArea
-gridInqArea = _CdiLib.gridInqArea
-gridHasArea = _CdiLib.gridHasArea
-gridDefNvertex = _CdiLib.gridDefNvertex
-gridInqNvertex = _CdiLib.gridInqNvertex
-gridDefXbounds = _CdiLib.gridDefXbounds
-gridInqXbounds = _CdiLib.gridInqXbounds
-gridDefYbounds = _CdiLib.gridDefYbounds
-gridInqYbounds = _CdiLib.gridInqYbounds
-gridDefRowlon = _CdiLib.gridDefRowlon
-gridInqRowlon = _CdiLib.gridInqRowlon
-gridChangeType = _CdiLib.gridChangeType
-zaxisName = _CdiLib.zaxisName
-zaxisCreate = _CdiLib.zaxisCreate
-zaxisDestroy = _CdiLib.zaxisDestroy
-zaxisInqType = _CdiLib.zaxisInqType
-zaxisInqSize = _CdiLib.zaxisInqSize
-zaxisDuplicate = _CdiLib.zaxisDuplicate
-zaxisResize = _CdiLib.zaxisResize
-zaxisPrint = _CdiLib.zaxisPrint
-zaxisSize = _CdiLib.zaxisSize
-zaxisDefLevels = _CdiLib.zaxisDefLevels
-zaxisInqLevels = _CdiLib.zaxisInqLevels
-zaxisDefLevel = _CdiLib.zaxisDefLevel
-zaxisInqLevel = _CdiLib.zaxisInqLevel
-zaxisDefName = _CdiLib.zaxisDefName
-zaxisDefLongname = _CdiLib.zaxisDefLongname
-zaxisDefUnits = _CdiLib.zaxisDefUnits
-zaxisInqName = _CdiLib.zaxisInqName
-zaxisInqLongname = _CdiLib.zaxisInqLongname
-zaxisInqUnits = _CdiLib.zaxisInqUnits
-zaxisDefDatatype = _CdiLib.zaxisDefDatatype
-zaxisInqDatatype = _CdiLib.zaxisInqDatatype
-zaxisDefLtype = _CdiLib.zaxisDefLtype
-zaxisInqLtype = _CdiLib.zaxisInqLtype
-zaxisInqLevelsPtr = _CdiLib.zaxisInqLevelsPtr
-zaxisDefVct = _CdiLib.zaxisDefVct
-zaxisInqVctSize = _CdiLib.zaxisInqVctSize
-zaxisInqVctPtr = _CdiLib.zaxisInqVctPtr
-zaxisInqLbounds = _CdiLib.zaxisInqLbounds
-zaxisInqUbounds = _CdiLib.zaxisInqUbounds
-zaxisInqWeights = _CdiLib.zaxisInqWeights
-zaxisInqLbound = _CdiLib.zaxisInqLbound
-zaxisInqUbound = _CdiLib.zaxisInqUbound
-zaxisDefLbounds = _CdiLib.zaxisDefLbounds
-zaxisDefUbounds = _CdiLib.zaxisDefUbounds
-zaxisDefWeights = _CdiLib.zaxisDefWeights
-zaxisChangeType = _CdiLib.zaxisChangeType
-taxisCreate = _CdiLib.taxisCreate
-taxisDestroy = _CdiLib.taxisDestroy
-taxisDuplicate = _CdiLib.taxisDuplicate
-taxisCopyTimestep = _CdiLib.taxisCopyTimestep
-taxisDefType = _CdiLib.taxisDefType
-taxisDefVdate = _CdiLib.taxisDefVdate
-taxisDefVtime = _CdiLib.taxisDefVtime
-taxisDefRdate = _CdiLib.taxisDefRdate
-taxisDefRtime = _CdiLib.taxisDefRtime
-taxisHasBounds = _CdiLib.taxisHasBounds
-taxisDefVdateBounds = _CdiLib.taxisDefVdateBounds
-taxisDefVtimeBounds = _CdiLib.taxisDefVtimeBounds
-taxisInqVdateBounds = _CdiLib.taxisInqVdateBounds
-taxisInqVtimeBounds = _CdiLib.taxisInqVtimeBounds
-taxisDefCalendar = _CdiLib.taxisDefCalendar
-taxisDefTunit = _CdiLib.taxisDefTunit
-taxisDefNumavg = _CdiLib.taxisDefNumavg
-taxisInqType = _CdiLib.taxisInqType
-taxisInqVdate = _CdiLib.taxisInqVdate
-taxisInqVtime = _CdiLib.taxisInqVtime
-taxisInqRdate = _CdiLib.taxisInqRdate
-taxisInqRtime = _CdiLib.taxisInqRtime
-taxisInqCalendar = _CdiLib.taxisInqCalendar
-taxisInqTunit = _CdiLib.taxisInqTunit
-taxisInqNumavg = _CdiLib.taxisInqNumavg
-tunitNamePtr = _CdiLib.tunitNamePtr
-institutDef = _CdiLib.institutDef
-institutInq = _CdiLib.institutInq
-institutInqNumber = _CdiLib.institutInqNumber
-institutInqCenter = _CdiLib.institutInqCenter
-institutInqSubcenter = _CdiLib.institutInqSubcenter
-institutInqNamePtr = _CdiLib.institutInqNamePtr
-institutInqLongnamePtr = _CdiLib.institutInqLongnamePtr
-modelDef = _CdiLib.modelDef
-modelInq = _CdiLib.modelInq
-modelInqInstitut = _CdiLib.modelInqInstitut
-modelInqGribID = _CdiLib.modelInqGribID
-modelInqNamePtr = _CdiLib.modelInqNamePtr
-tableWriteC = _CdiLib.tableWriteC
-tableWrite = _CdiLib.tableWrite
-tableRead = _CdiLib.tableRead
-tableDef = _CdiLib.tableDef
-tableInqNamePtr = _CdiLib.tableInqNamePtr
-tableDefEntry = _CdiLib.tableDefEntry
-tableInq = _CdiLib.tableInq
-tableInqNumber = _CdiLib.tableInqNumber
-tableInqNum = _CdiLib.tableInqNum
-tableInqModel = _CdiLib.tableInqModel
-tableInqPar = _CdiLib.tableInqPar
-tableInqParCode = _CdiLib.tableInqParCode
-tableInqParName = _CdiLib.tableInqParName
-tableInqParLongname = _CdiLib.tableInqParLongname
-tableInqParUnits = _CdiLib.tableInqParUnits
-tableInqParNamePtr = _CdiLib.tableInqParNamePtr
-tableInqParLongnamePtr = _CdiLib.tableInqParLongnamePtr
-tableInqParUnitsPtr = _CdiLib.tableInqParUnitsPtr
-streamDefHistory = _CdiLib.streamDefHistory
-streamInqHistorySize = _CdiLib.streamInqHistorySize
-streamInqHistoryString = _CdiLib.streamInqHistoryString
+CDI_UUID_SIZE = _CdiLib.CDI_UUID_SIZE
+class CdiParam(object):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ discipline = property(_CdiLib.CdiParam_discipline_get, _CdiLib.CdiParam_discipline_set)
+ category = property(_CdiLib.CdiParam_category_get, _CdiLib.CdiParam_category_set)
+ number = property(_CdiLib.CdiParam_number_get, _CdiLib.CdiParam_number_set)
+
+ def __init__(self):
+ _CdiLib.CdiParam_swiginit(self, _CdiLib.new_CdiParam())
+ __swig_destroy__ = _CdiLib.delete_CdiParam
+
+# Register CdiParam in _CdiLib:
+_CdiLib.CdiParam_swigregister(CdiParam)
+
+
+def cdiReset():
+ return _CdiLib.cdiReset()
+
+def cdiStringError(cdiErrno):
+ return _CdiLib.cdiStringError(cdiErrno)
+
+def cdiDebug(debug):
+ return _CdiLib.cdiDebug(debug)
+
+def cdiLibraryVersion():
+ return _CdiLib.cdiLibraryVersion()
+
+def cdiPrintVersion():
+ return _CdiLib.cdiPrintVersion()
+
+def cdiHaveFiletype(filetype):
+ return _CdiLib.cdiHaveFiletype(filetype)
+
+def cdiDefMissval(missval):
+ return _CdiLib.cdiDefMissval(missval)
+
+def cdiInqMissval():
+ return _CdiLib.cdiInqMissval()
+
+def cdiInqGridMissval():
+ return _CdiLib.cdiInqGridMissval()
+
+def cdiDefGlobal(string, val):
+ return _CdiLib.cdiDefGlobal(string, val)
+
+def namespaceNew():
+ return _CdiLib.namespaceNew()
+
+def namespaceSetActive(namespaceID):
+ return _CdiLib.namespaceSetActive(namespaceID)
+
+def namespaceGetActive():
+ return _CdiLib.namespaceGetActive()
+
+def namespaceDelete(namespaceID):
+ return _CdiLib.namespaceDelete(namespaceID)
+
+def cdiParamToString(param, paramstr, maxlen):
+ return _CdiLib.cdiParamToString(param, paramstr, maxlen)
+
+def cdiDecodeParam(param, pnum, pcat, pdis):
+ return _CdiLib.cdiDecodeParam(param, pnum, pcat, pdis)
+
+def cdiEncodeParam(pnum, pcat, pdis):
+ return _CdiLib.cdiEncodeParam(pnum, pcat, pdis)
+
+def cdiDecodeDate(date, year, month, day):
+ return _CdiLib.cdiDecodeDate(date, year, month, day)
+
+def cdiEncodeDate(year, month, day):
+ return _CdiLib.cdiEncodeDate(year, month, day)
+
+def cdiDecodeTime(time, hour, minute, second):
+ return _CdiLib.cdiDecodeTime(time, hour, minute, second)
+
+def cdiEncodeTime(hour, minute, second):
+ return _CdiLib.cdiEncodeTime(hour, minute, second)
+
+def cdiGetFiletype(path, byteorder):
+ return _CdiLib.cdiGetFiletype(path, byteorder)
+
+def streamOpenRead(path):
+ return _CdiLib.streamOpenRead(path)
+
+def streamOpenWrite(path, filetype):
+ return _CdiLib.streamOpenWrite(path, filetype)
+
+def streamOpenAppend(path):
+ return _CdiLib.streamOpenAppend(path)
+
+def streamClose(streamID):
+ return _CdiLib.streamClose(streamID)
+
+def streamSync(streamID):
+ return _CdiLib.streamSync(streamID)
+
+def streamDefNumWorker(streamID, numWorker):
+ return _CdiLib.streamDefNumWorker(streamID, numWorker)
+
+def streamDefVlist(streamID, vlistID):
+ return _CdiLib.streamDefVlist(streamID, vlistID)
+
+def streamInqVlist(streamID):
+ return _CdiLib.streamInqVlist(streamID)
+
+def streamInqFiletype(streamID):
+ return _CdiLib.streamInqFiletype(streamID)
+
+def streamDefByteorder(streamID, byteorder):
+ return _CdiLib.streamDefByteorder(streamID, byteorder)
+
+def streamInqByteorder(streamID):
+ return _CdiLib.streamInqByteorder(streamID)
+
+def streamDefCompType(streamID, comptype):
+ return _CdiLib.streamDefCompType(streamID, comptype)
+
+def streamInqCompType(streamID):
+ return _CdiLib.streamInqCompType(streamID)
+
+def streamDefCompLevel(streamID, complevel):
+ return _CdiLib.streamDefCompLevel(streamID, complevel)
+
+def streamInqCompLevel(streamID):
+ return _CdiLib.streamInqCompLevel(streamID)
+
+def streamDefTimestep(streamID, tsID):
+ return _CdiLib.streamDefTimestep(streamID, tsID)
+
+def streamInqTimestep(streamID, tsID):
+ return _CdiLib.streamInqTimestep(streamID, tsID)
+
+def streamInqCurTimestepID(streamID):
+ return _CdiLib.streamInqCurTimestepID(streamID)
+
+def streamFilename(streamID):
+ return _CdiLib.streamFilename(streamID)
+
+def streamFilesuffix(filetype):
+ return _CdiLib.streamFilesuffix(filetype)
+
+def streamNvals(streamID):
+ return _CdiLib.streamNvals(streamID)
+
+def streamInqNvars(streamID):
+ return _CdiLib.streamInqNvars(streamID)
+
+def streamWriteVar(streamID, varID, data, nmiss):
+ return _CdiLib.streamWriteVar(streamID, varID, data, nmiss)
+
+def streamWriteVarF(streamID, varID, data, nmiss):
+ return _CdiLib.streamWriteVarF(streamID, varID, data, nmiss)
+
+def streamReadVar(streamID, varID, data, nmiss):
+ return _CdiLib.streamReadVar(streamID, varID, data, nmiss)
+
+def streamReadVarF(streamID, varID, data, nmiss):
+ return _CdiLib.streamReadVarF(streamID, varID, data, nmiss)
+
+def streamReadVarPart(streamID, varID, varType, start, size, data, nmiss, memtype):
+ return _CdiLib.streamReadVarPart(streamID, varID, varType, start, size, data, nmiss, memtype)
+
+def streamWriteVarSlice(streamID, varID, levelID, data, nmiss):
+ return _CdiLib.streamWriteVarSlice(streamID, varID, levelID, data, nmiss)
+
+def streamWriteVarSliceF(streamID, varID, levelID, data, nmiss):
+ return _CdiLib.streamWriteVarSliceF(streamID, varID, levelID, data, nmiss)
+
+def streamReadVarSlicePart(streamID, varID, levelID, varType, start, size, data, nmiss, memtype):
+ return _CdiLib.streamReadVarSlicePart(streamID, varID, levelID, varType, start, size, data, nmiss, memtype)
+
+def streamReadVarSlice(streamID, varID, levelID, data, nmiss):
+ return _CdiLib.streamReadVarSlice(streamID, varID, levelID, data, nmiss)
+
+def streamReadVarSliceF(streamID, varID, levelID, data, nmiss):
+ return _CdiLib.streamReadVarSliceF(streamID, varID, levelID, data, nmiss)
+
+def streamWriteVarChunk(streamID, varID, rect, data, nmiss):
+ return _CdiLib.streamWriteVarChunk(streamID, varID, rect, data, nmiss)
+
+def streamDefRecord(streamID, varID, levelID):
+ return _CdiLib.streamDefRecord(streamID, varID, levelID)
+
+def streamInqRecord(streamID, varID, levelID):
+ return _CdiLib.streamInqRecord(streamID, varID, levelID)
+
+def streamWriteRecord(streamID, data, nmiss):
+ return _CdiLib.streamWriteRecord(streamID, data, nmiss)
+
+def streamWriteRecordF(streamID, data, nmiss):
+ return _CdiLib.streamWriteRecordF(streamID, data, nmiss)
+
+def streamReadRecord(streamID, data, nmiss):
+ return _CdiLib.streamReadRecord(streamID, data, nmiss)
+
+def streamReadRecordF(streamID, data, nmiss):
+ return _CdiLib.streamReadRecordF(streamID, data, nmiss)
+
+def streamCopyRecord(streamIDdest, streamIDsrc):
+ return _CdiLib.streamCopyRecord(streamIDdest, streamIDsrc)
+
+def streamInqGRIBinfo(streamID, intnum, fltnum, bignum):
+ return _CdiLib.streamInqGRIBinfo(streamID, intnum, fltnum, bignum)
+
+def cdiIterator_new(path):
+ return _CdiLib.cdiIterator_new(path)
+
+def cdiIterator_clone(me):
+ return _CdiLib.cdiIterator_clone(me)
+
+def cdiIterator_serialize(me):
+ return _CdiLib.cdiIterator_serialize(me)
+
+def cdiIterator_deserialize(description):
+ return _CdiLib.cdiIterator_deserialize(description)
+
+def cdiIterator_print(me, stream):
+ return _CdiLib.cdiIterator_print(me, stream)
+
+def cdiIterator_delete(me):
+ return _CdiLib.cdiIterator_delete(me)
+
+def cdiIterator_nextField(me):
+ return _CdiLib.cdiIterator_nextField(me)
+
+def cdiIterator_inqStartTime(me):
+ return _CdiLib.cdiIterator_inqStartTime(me)
+
+def cdiIterator_inqEndTime(me):
+ return _CdiLib.cdiIterator_inqEndTime(me)
+
+def cdiIterator_inqRTime(me):
+ return _CdiLib.cdiIterator_inqRTime(me)
+
+def cdiIterator_inqVTime(me):
+ return _CdiLib.cdiIterator_inqVTime(me)
+
+def cdiIterator_inqLevelType(me, levelSelector, outName_optional, outLongName_optional, outStdName_optional, outUnit_optional):
+ return _CdiLib.cdiIterator_inqLevelType(me, levelSelector, outName_optional, outLongName_optional, outStdName_optional, outUnit_optional)
+
+def cdiIterator_inqLevel(me, levelSelector, outValue1_optional, outValue2_optional):
+ return _CdiLib.cdiIterator_inqLevel(me, levelSelector, outValue1_optional, outValue2_optional)
+
+def cdiIterator_inqLevelUuid(me, outVgridNumber_optional, outLevelCount_optional, outUuid_optional):
+ return _CdiLib.cdiIterator_inqLevelUuid(me, outVgridNumber_optional, outLevelCount_optional, outUuid_optional)
+
+def cdiIterator_inqTile(me, outTileIndex, outTileAttribute):
+ return _CdiLib.cdiIterator_inqTile(me, outTileIndex, outTileAttribute)
+
+def cdiIterator_inqTileCount(me, outTileCount, outTileAttributeCount):
+ return _CdiLib.cdiIterator_inqTileCount(me, outTileCount, outTileAttributeCount)
+
+def cdiIterator_inqParam(me):
+ return _CdiLib.cdiIterator_inqParam(me)
+
+def cdiIterator_inqParamParts(me, outDiscipline, outCategory, outNumber):
+ return _CdiLib.cdiIterator_inqParamParts(me, outDiscipline, outCategory, outNumber)
+
+def cdiIterator_inqDatatype(me):
+ return _CdiLib.cdiIterator_inqDatatype(me)
+
+def cdiIterator_inqFiletype(me):
+ return _CdiLib.cdiIterator_inqFiletype(me)
+
+def cdiIterator_inqTsteptype(me):
+ return _CdiLib.cdiIterator_inqTsteptype(me)
+
+def cdiIterator_inqVariableName(me):
+ return _CdiLib.cdiIterator_inqVariableName(me)
+
+def cdiIterator_inqGridId(me):
+ return _CdiLib.cdiIterator_inqGridId(me)
+
+def cdiIterator_readField(me, data, nmiss_optional):
+ return _CdiLib.cdiIterator_readField(me, data, nmiss_optional)
+
+def cdiIterator_readFieldF(me, data, nmiss_optional):
+ return _CdiLib.cdiIterator_readFieldF(me, data, nmiss_optional)
+
+def cdiGribIterator_clone(me):
+ return _CdiLib.cdiGribIterator_clone(me)
+
+def cdiGribIterator_delete(me):
+ return _CdiLib.cdiGribIterator_delete(me)
+
+def cdiGribIterator_getLong(me, key, value):
+ return _CdiLib.cdiGribIterator_getLong(me, key, value)
+
+def cdiGribIterator_getDouble(me, key, value):
+ return _CdiLib.cdiGribIterator_getDouble(me, key, value)
+
+def cdiGribIterator_getLength(me, key, value):
+ return _CdiLib.cdiGribIterator_getLength(me, key, value)
+
+def cdiGribIterator_getString(me, key, value, length):
+ return _CdiLib.cdiGribIterator_getString(me, key, value, length)
+
+def cdiGribIterator_getSize(me, key, value):
+ return _CdiLib.cdiGribIterator_getSize(me, key, value)
+
+def cdiGribIterator_getLongArray(me, key, value, array_size):
+ return _CdiLib.cdiGribIterator_getLongArray(me, key, value, array_size)
+
+def cdiGribIterator_getDoubleArray(me, key, value, array_size):
+ return _CdiLib.cdiGribIterator_getDoubleArray(me, key, value, array_size)
+
+def cdiGribIterator_inqEdition(me):
+ return _CdiLib.cdiGribIterator_inqEdition(me)
+
+def cdiGribIterator_inqLongValue(me, key):
+ return _CdiLib.cdiGribIterator_inqLongValue(me, key)
+
+def cdiGribIterator_inqLongDefaultValue(me, key, defaultValue):
+ return _CdiLib.cdiGribIterator_inqLongDefaultValue(me, key, defaultValue)
+
+def cdiGribIterator_inqDoubleValue(me, key):
+ return _CdiLib.cdiGribIterator_inqDoubleValue(me, key)
+
+def cdiGribIterator_inqDoubleDefaultValue(me, key, defaultValue):
+ return _CdiLib.cdiGribIterator_inqDoubleDefaultValue(me, key, defaultValue)
+
+def cdiGribIterator_inqStringValue(me, key):
+ return _CdiLib.cdiGribIterator_inqStringValue(me, key)
+
+def vlistCreate():
+ return _CdiLib.vlistCreate()
+
+def vlistDestroy(vlistID):
+ return _CdiLib.vlistDestroy(vlistID)
+
+def vlistDuplicate(vlistID):
+ return _CdiLib.vlistDuplicate(vlistID)
+
+def vlistCopy(vlistID2, vlistID1):
+ return _CdiLib.vlistCopy(vlistID2, vlistID1)
+
+def vlistCopyFlag(vlistID2, vlistID1):
+ return _CdiLib.vlistCopyFlag(vlistID2, vlistID1)
+
+def vlistClearFlag(vlistID):
+ return _CdiLib.vlistClearFlag(vlistID)
+
+def vlistCat(vlistID2, vlistID1):
+ return _CdiLib.vlistCat(vlistID2, vlistID1)
+
+def vlistMerge(vlistID2, vlistID1):
+ return _CdiLib.vlistMerge(vlistID2, vlistID1)
+
+def vlistPrint(vlistID):
+ return _CdiLib.vlistPrint(vlistID)
+
+def vlistNumber(vlistID):
+ return _CdiLib.vlistNumber(vlistID)
+
+def vlistNvars(vlistID):
+ return _CdiLib.vlistNvars(vlistID)
+
+def vlistNgrids(vlistID):
+ return _CdiLib.vlistNgrids(vlistID)
+
+def vlistNzaxis(vlistID):
+ return _CdiLib.vlistNzaxis(vlistID)
+
+def vlistNsubtypes(vlistID):
+ return _CdiLib.vlistNsubtypes(vlistID)
+
+def vlistDefNtsteps(vlistID, nts):
+ return _CdiLib.vlistDefNtsteps(vlistID, nts)
+
+def vlistNtsteps(vlistID):
+ return _CdiLib.vlistNtsteps(vlistID)
+
+def vlistGridsizeMax(vlistID):
+ return _CdiLib.vlistGridsizeMax(vlistID)
+
+def vlistGrid(vlistID, index):
+ return _CdiLib.vlistGrid(vlistID, index)
+
+def vlistGridIndex(vlistID, gridID):
+ return _CdiLib.vlistGridIndex(vlistID, gridID)
+
+def vlistChangeGridIndex(vlistID, index, gridID):
+ return _CdiLib.vlistChangeGridIndex(vlistID, index, gridID)
+
+def vlistChangeGrid(vlistID, gridID1, gridID2):
+ return _CdiLib.vlistChangeGrid(vlistID, gridID1, gridID2)
+
+def vlistZaxis(vlistID, index):
+ return _CdiLib.vlistZaxis(vlistID, index)
+
+def vlistZaxisIndex(vlistID, zaxisID):
+ return _CdiLib.vlistZaxisIndex(vlistID, zaxisID)
+
+def vlistChangeZaxisIndex(vlistID, index, zaxisID):
+ return _CdiLib.vlistChangeZaxisIndex(vlistID, index, zaxisID)
+
+def vlistChangeZaxis(vlistID, zaxisID1, zaxisID2):
+ return _CdiLib.vlistChangeZaxis(vlistID, zaxisID1, zaxisID2)
+
+def vlistNrecs(vlistID):
+ return _CdiLib.vlistNrecs(vlistID)
+
+def vlistSubtype(vlistID, index):
+ return _CdiLib.vlistSubtype(vlistID, index)
+
+def vlistSubtypeIndex(vlistID, subtypeID):
+ return _CdiLib.vlistSubtypeIndex(vlistID, subtypeID)
+
+def vlistDefTaxis(vlistID, taxisID):
+ return _CdiLib.vlistDefTaxis(vlistID, taxisID)
+
+def vlistInqTaxis(vlistID):
+ return _CdiLib.vlistInqTaxis(vlistID)
+
+def vlistDefTable(vlistID, tableID):
+ return _CdiLib.vlistDefTable(vlistID, tableID)
+
+def vlistInqTable(vlistID):
+ return _CdiLib.vlistInqTable(vlistID)
+
+def vlistDefInstitut(vlistID, instID):
+ return _CdiLib.vlistDefInstitut(vlistID, instID)
+
+def vlistInqInstitut(vlistID):
+ return _CdiLib.vlistInqInstitut(vlistID)
+
+def vlistDefModel(vlistID, modelID):
+ return _CdiLib.vlistDefModel(vlistID, modelID)
+
+def vlistInqModel(vlistID):
+ return _CdiLib.vlistInqModel(vlistID)
+
+def vlistDefVarTiles(vlistID, gridID, zaxisID, timetype, tilesetID):
+ return _CdiLib.vlistDefVarTiles(vlistID, gridID, zaxisID, timetype, tilesetID)
+
+def vlistDefVar(vlistID, gridID, zaxisID, timetype):
+ return _CdiLib.vlistDefVar(vlistID, gridID, zaxisID, timetype)
+
+def vlistChangeVarGrid(vlistID, varID, gridID):
+ return _CdiLib.vlistChangeVarGrid(vlistID, varID, gridID)
+
+def vlistChangeVarZaxis(vlistID, varID, zaxisID):
+ return _CdiLib.vlistChangeVarZaxis(vlistID, varID, zaxisID)
+
+def vlistInqVar(vlistID, varID, gridID, zaxisID, timetype):
+ return _CdiLib.vlistInqVar(vlistID, varID, gridID, zaxisID, timetype)
+
+def vlistInqVarGrid(vlistID, varID):
+ return _CdiLib.vlistInqVarGrid(vlistID, varID)
+
+def vlistInqVarZaxis(vlistID, varID):
+ return _CdiLib.vlistInqVarZaxis(vlistID, varID)
+
+def vlistInqVarID(vlistID, code):
+ return _CdiLib.vlistInqVarID(vlistID, code)
+
+def vlistDefVarTimetype(vlistID, varID, timetype):
+ return _CdiLib.vlistDefVarTimetype(vlistID, varID, timetype)
+
+def vlistInqVarTimetype(vlistID, varID):
+ return _CdiLib.vlistInqVarTimetype(vlistID, varID)
+
+def vlistDefVarTsteptype(vlistID, varID, tsteptype):
+ return _CdiLib.vlistDefVarTsteptype(vlistID, varID, tsteptype)
+
+def vlistInqVarTsteptype(vlistID, varID):
+ return _CdiLib.vlistInqVarTsteptype(vlistID, varID)
+
+def vlistDefVarCompType(vlistID, varID, comptype):
+ return _CdiLib.vlistDefVarCompType(vlistID, varID, comptype)
+
+def vlistInqVarCompType(vlistID, varID):
+ return _CdiLib.vlistInqVarCompType(vlistID, varID)
+
+def vlistDefVarCompLevel(vlistID, varID, complevel):
+ return _CdiLib.vlistDefVarCompLevel(vlistID, varID, complevel)
+
+def vlistInqVarCompLevel(vlistID, varID):
+ return _CdiLib.vlistInqVarCompLevel(vlistID, varID)
+
+def vlistDefVarParam(vlistID, varID, param):
+ return _CdiLib.vlistDefVarParam(vlistID, varID, param)
+
+def vlistInqVarParam(vlistID, varID):
+ return _CdiLib.vlistInqVarParam(vlistID, varID)
+
+def vlistDefVarCode(vlistID, varID, code):
+ return _CdiLib.vlistDefVarCode(vlistID, varID, code)
+
+def vlistInqVarCode(vlistID, varID):
+ return _CdiLib.vlistInqVarCode(vlistID, varID)
+
+def vlistDefVarDatatype(vlistID, varID, datatype):
+ return _CdiLib.vlistDefVarDatatype(vlistID, varID, datatype)
+
+def vlistInqVarDatatype(vlistID, varID):
+ return _CdiLib.vlistInqVarDatatype(vlistID, varID)
+
+def vlistDefVarChunkType(vlistID, varID, chunktype):
+ return _CdiLib.vlistDefVarChunkType(vlistID, varID, chunktype)
+
+def vlistInqVarChunkType(vlistID, varID):
+ return _CdiLib.vlistInqVarChunkType(vlistID, varID)
+
+def vlistDefVarXYZ(vlistID, varID, xyz):
+ return _CdiLib.vlistDefVarXYZ(vlistID, varID, xyz)
+
+def vlistInqVarXYZ(vlistID, varID):
+ return _CdiLib.vlistInqVarXYZ(vlistID, varID)
+
+def vlistInqVarNumber(vlistID, varID):
+ return _CdiLib.vlistInqVarNumber(vlistID, varID)
+
+def vlistDefVarInstitut(vlistID, varID, instID):
+ return _CdiLib.vlistDefVarInstitut(vlistID, varID, instID)
+
+def vlistInqVarInstitut(vlistID, varID):
+ return _CdiLib.vlistInqVarInstitut(vlistID, varID)
+
+def vlistDefVarModel(vlistID, varID, modelID):
+ return _CdiLib.vlistDefVarModel(vlistID, varID, modelID)
+
+def vlistInqVarModel(vlistID, varID):
+ return _CdiLib.vlistInqVarModel(vlistID, varID)
+
+def vlistDefVarTable(vlistID, varID, tableID):
+ return _CdiLib.vlistDefVarTable(vlistID, varID, tableID)
+
+def vlistInqVarTable(vlistID, varID):
+ return _CdiLib.vlistInqVarTable(vlistID, varID)
+
+def vlistDefVarName(vlistID, varID, name):
+ return _CdiLib.vlistDefVarName(vlistID, varID, name)
+
+def vlistInqVarName(vlistID, varID, name):
+ return _CdiLib.vlistInqVarName(vlistID, varID, name)
+
+def vlistCopyVarName(vlistId, varId):
+ return _CdiLib.vlistCopyVarName(vlistId, varId)
+
+def vlistDefVarStdname(vlistID, varID, stdname):
+ return _CdiLib.vlistDefVarStdname(vlistID, varID, stdname)
+
+def vlistInqVarStdname(vlistID, varID, stdname):
+ return _CdiLib.vlistInqVarStdname(vlistID, varID, stdname)
+
+def vlistDefVarLongname(vlistID, varID, longname):
+ return _CdiLib.vlistDefVarLongname(vlistID, varID, longname)
+
+def vlistInqVarLongname(vlistID, varID, longname):
+ return _CdiLib.vlistInqVarLongname(vlistID, varID, longname)
+
+def vlistDefVarUnits(vlistID, varID, units):
+ return _CdiLib.vlistDefVarUnits(vlistID, varID, units)
+
+def vlistInqVarUnits(vlistID, varID, units):
+ return _CdiLib.vlistInqVarUnits(vlistID, varID, units)
+
+def vlistDefVarMissval(vlistID, varID, missval):
+ return _CdiLib.vlistDefVarMissval(vlistID, varID, missval)
+
+def vlistInqVarMissval(vlistID, varID):
+ return _CdiLib.vlistInqVarMissval(vlistID, varID)
+
+def vlistDefVarExtra(vlistID, varID, extra):
+ return _CdiLib.vlistDefVarExtra(vlistID, varID, extra)
+
+def vlistInqVarExtra(vlistID, varID, extra):
+ return _CdiLib.vlistInqVarExtra(vlistID, varID, extra)
+
+def vlistDefVarScalefactor(vlistID, varID, scalefactor):
+ return _CdiLib.vlistDefVarScalefactor(vlistID, varID, scalefactor)
+
+def vlistInqVarScalefactor(vlistID, varID):
+ return _CdiLib.vlistInqVarScalefactor(vlistID, varID)
+
+def vlistDefVarAddoffset(vlistID, varID, addoffset):
+ return _CdiLib.vlistDefVarAddoffset(vlistID, varID, addoffset)
+
+def vlistInqVarAddoffset(vlistID, varID):
+ return _CdiLib.vlistInqVarAddoffset(vlistID, varID)
+
+def vlistDefVarTimave(vlistID, varID, timave):
+ return _CdiLib.vlistDefVarTimave(vlistID, varID, timave)
+
+def vlistInqVarTimave(vlistID, varID):
+ return _CdiLib.vlistInqVarTimave(vlistID, varID)
+
+def vlistInqVarSize(vlistID, varID):
+ return _CdiLib.vlistInqVarSize(vlistID, varID)
+
+def vlistDefIndex(vlistID, varID, levID, index):
+ return _CdiLib.vlistDefIndex(vlistID, varID, levID, index)
+
+def vlistInqIndex(vlistID, varID, levID):
+ return _CdiLib.vlistInqIndex(vlistID, varID, levID)
+
+def vlistDefFlag(vlistID, varID, levID, flag):
+ return _CdiLib.vlistDefFlag(vlistID, varID, levID, flag)
+
+def vlistInqFlag(vlistID, varID, levID):
+ return _CdiLib.vlistInqFlag(vlistID, varID, levID)
+
+def vlistFindVar(vlistID, fvarID):
+ return _CdiLib.vlistFindVar(vlistID, fvarID)
+
+def vlistFindLevel(vlistID, fvarID, flevelID):
+ return _CdiLib.vlistFindLevel(vlistID, fvarID, flevelID)
+
+def vlistMergedVar(vlistID, varID):
+ return _CdiLib.vlistMergedVar(vlistID, varID)
+
+def vlistMergedLevel(vlistID, varID, levelID):
+ return _CdiLib.vlistMergedLevel(vlistID, varID, levelID)
+
+def cdiClearAdditionalKeys():
+ return _CdiLib.cdiClearAdditionalKeys()
+
+def cdiDefAdditionalKey(string):
+ return _CdiLib.cdiDefAdditionalKey(string)
+
+def vlistDefVarIntKey(vlistID, varID, name, value):
+ return _CdiLib.vlistDefVarIntKey(vlistID, varID, name, value)
+
+def vlistDefVarDblKey(vlistID, varID, name, value):
+ return _CdiLib.vlistDefVarDblKey(vlistID, varID, name, value)
+
+def vlistHasVarKey(vlistID, varID, name):
+ return _CdiLib.vlistHasVarKey(vlistID, varID, name)
+
+def vlistInqVarDblKey(vlistID, varID, name):
+ return _CdiLib.vlistInqVarDblKey(vlistID, varID, name)
+
+def vlistInqVarIntKey(vlistID, varID, name):
+ return _CdiLib.vlistInqVarIntKey(vlistID, varID, name)
+
+def cdiInqNatts(cdiID, varID, nattsp):
+ return _CdiLib.cdiInqNatts(cdiID, varID, nattsp)
+
+def cdiInqAtt(cdiID, varID, attrnum, name, typep, lenp):
+ return _CdiLib.cdiInqAtt(cdiID, varID, attrnum, name, typep, lenp)
+
+def cdiDelAtt(cdiID, varID, name):
+ return _CdiLib.cdiDelAtt(cdiID, varID, name)
+
+def cdiCopyAtts(cdiID1, varID1, cdiID2, varID2):
+ return _CdiLib.cdiCopyAtts(cdiID1, varID1, cdiID2, varID2)
+
+def cdiDefAttInt(cdiID, varID, name, type, len, ip):
+ return _CdiLib.cdiDefAttInt(cdiID, varID, name, type, len, ip)
+
+def cdiDefAttFlt(cdiID, varID, name, type, len, dp):
+ return _CdiLib.cdiDefAttFlt(cdiID, varID, name, type, len, dp)
+
+def cdiDefAttTxt(cdiID, varID, name, len, tp_cbuf):
+ return _CdiLib.cdiDefAttTxt(cdiID, varID, name, len, tp_cbuf)
+
+def cdiInqAttInt(cdiID, varID, name, mlen, ip):
+ return _CdiLib.cdiInqAttInt(cdiID, varID, name, mlen, ip)
+
+def cdiInqAttFlt(cdiID, varID, name, mlen, dp):
+ return _CdiLib.cdiInqAttFlt(cdiID, varID, name, mlen, dp)
+
+def cdiInqAttTxt(cdiID, varID, name, mlen, tp_cbuf):
+ return _CdiLib.cdiInqAttTxt(cdiID, varID, name, mlen, tp_cbuf)
+
+def gridName(gridtype, gridname):
+ return _CdiLib.gridName(gridtype, gridname)
+
+def gridNamePtr(gridtype):
+ return _CdiLib.gridNamePtr(gridtype)
+
+def gridCompress(gridID):
+ return _CdiLib.gridCompress(gridID)
+
+def gridDefMaskGME(gridID, mask):
+ return _CdiLib.gridDefMaskGME(gridID, mask)
+
+def gridInqMaskGME(gridID, mask):
+ return _CdiLib.gridInqMaskGME(gridID, mask)
+
+def gridDefMask(gridID, mask):
+ return _CdiLib.gridDefMask(gridID, mask)
+
+def gridInqMask(gridID, mask):
+ return _CdiLib.gridInqMask(gridID, mask)
+
+def gridCreate(gridtype, size):
+ return _CdiLib.gridCreate(gridtype, size)
+
+def gridDestroy(gridID):
+ return _CdiLib.gridDestroy(gridID)
+
+def gridDuplicate(gridID):
+ return _CdiLib.gridDuplicate(gridID)
+
+def gridDefProj(gridID, projID):
+ return _CdiLib.gridDefProj(gridID, projID)
+
+def gridInqProj(gridID):
+ return _CdiLib.gridInqProj(gridID)
+
+def gridInqProjType(gridID):
+ return _CdiLib.gridInqProjType(gridID)
+
+def gridInqType(gridID):
+ return _CdiLib.gridInqType(gridID)
+
+def gridInqSize(gridID):
+ return _CdiLib.gridInqSize(gridID)
+
+def gridDefXsize(gridID, xsize):
+ return _CdiLib.gridDefXsize(gridID, xsize)
+
+def gridInqXsize(gridID):
+ return _CdiLib.gridInqXsize(gridID)
+
+def gridDefYsize(gridID, ysize):
+ return _CdiLib.gridDefYsize(gridID, ysize)
+
+def gridInqYsize(gridID):
+ return _CdiLib.gridInqYsize(gridID)
+
+def gridDefNP(gridID, np):
+ return _CdiLib.gridDefNP(gridID, np)
+
+def gridInqNP(gridID):
+ return _CdiLib.gridInqNP(gridID)
+
+def gridDefXvals(gridID, xvals):
+ return _CdiLib.gridDefXvals(gridID, xvals)
+
+def gridInqXvals(gridID, xvals):
+ return _CdiLib.gridInqXvals(gridID, xvals)
+
+def gridInqXvalsPart(gridID, start, size, xvals):
+ return _CdiLib.gridInqXvalsPart(gridID, start, size, xvals)
+
+def gridInqXIsc(gridID):
+ return _CdiLib.gridInqXIsc(gridID)
+
+def gridInqXCvals(gridID, xcvals):
+ return _CdiLib.gridInqXCvals(gridID, xcvals)
+
+def gridDefYvals(gridID, yvals):
+ return _CdiLib.gridDefYvals(gridID, yvals)
+
+def gridInqYvals(gridID, yvals):
+ return _CdiLib.gridInqYvals(gridID, yvals)
+
+def gridInqYvalsPart(gridID, start, size, yvals):
+ return _CdiLib.gridInqYvalsPart(gridID, start, size, yvals)
+
+def gridInqYIsc(gridID):
+ return _CdiLib.gridInqYIsc(gridID)
+
+def gridInqYCvals(gridID, ycvals):
+ return _CdiLib.gridInqYCvals(gridID, ycvals)
+CDI_KEY_TABLESVERSION = _CdiLib.CDI_KEY_TABLESVERSION
+CDI_KEY_LOCALTABLESVERSION = _CdiLib.CDI_KEY_LOCALTABLESVERSION
+CDI_KEY_TYPEOFGENERATINGPROCESS = _CdiLib.CDI_KEY_TYPEOFGENERATINGPROCESS
+CDI_KEY_PRODUCTDEFINITIONTEMPLATE = _CdiLib.CDI_KEY_PRODUCTDEFINITIONTEMPLATE
+CDI_KEY_TYPEOFPROCESSEDDATA = _CdiLib.CDI_KEY_TYPEOFPROCESSEDDATA
+CDI_KEY_SHAPEOFTHEEARTH = _CdiLib.CDI_KEY_SHAPEOFTHEEARTH
+CDI_KEY_BACKGROUNDPROCESS = _CdiLib.CDI_KEY_BACKGROUNDPROCESS
+CDI_KEY_TYPEOFENSEMBLEFORECAST = _CdiLib.CDI_KEY_TYPEOFENSEMBLEFORECAST
+CDI_KEY_NUMBEROFFORECASTSINENSEMBLE = _CdiLib.CDI_KEY_NUMBEROFFORECASTSINENSEMBLE
+CDI_KEY_PERTURBATIONNUMBER = _CdiLib.CDI_KEY_PERTURBATIONNUMBER
+CDI_KEY_CENTRE = _CdiLib.CDI_KEY_CENTRE
+CDI_KEY_SUBCENTRE = _CdiLib.CDI_KEY_SUBCENTRE
+CDI_KEY_MPIMTYPE = _CdiLib.CDI_KEY_MPIMTYPE
+CDI_KEY_MPIMCLASS = _CdiLib.CDI_KEY_MPIMCLASS
+CDI_KEY_MPIMUSER = _CdiLib.CDI_KEY_MPIMUSER
+CDI_KEY_REVSTATUS = _CdiLib.CDI_KEY_REVSTATUS
+CDI_KEY_REVNUMBER = _CdiLib.CDI_KEY_REVNUMBER
+CDI_KEY_GRIB2LOCALSECTIONNUMBER = _CdiLib.CDI_KEY_GRIB2LOCALSECTIONNUMBER
+CDI_KEY_SECTION2PADDINGLENGTH = _CdiLib.CDI_KEY_SECTION2PADDINGLENGTH
+CDI_KEY_SECTION2PADDING = _CdiLib.CDI_KEY_SECTION2PADDING
+CDI_KEY_UVRELATIVETOGRID = _CdiLib.CDI_KEY_UVRELATIVETOGRID
+CDI_KEY_CONSTITUENTTYPE = _CdiLib.CDI_KEY_CONSTITUENTTYPE
+
+def cdiDefKeyInt(cdiID, varID, key, value):
+ return _CdiLib.cdiDefKeyInt(cdiID, varID, key, value)
+
+def cdiInqKeyInt(cdiID, varID, key, value):
+ return _CdiLib.cdiInqKeyInt(cdiID, varID, key, value)
+
+def cdiDefKeyBytes(cdiID, varID, key, bytes, length):
+ return _CdiLib.cdiDefKeyBytes(cdiID, varID, key, bytes, length)
+
+def cdiInqKeyBytes(cdiID, varID, key, bytes, length):
+ return _CdiLib.cdiInqKeyBytes(cdiID, varID, key, bytes, length)
+
+def cdiDefKeyString(cdiID, varID, key, string):
+ return _CdiLib.cdiDefKeyString(cdiID, varID, key, string)
+
+def cdiInqKeyString(cdiID, varID, key, string, length):
+ return _CdiLib.cdiInqKeyString(cdiID, varID, key, string, length)
+
+def cdiInqKeyLen(cdiID, varID, key, length):
+ return _CdiLib.cdiInqKeyLen(cdiID, varID, key, length)
+
+def cdiCopyKeys(cdiID1, varID1, cdiID2, varID2):
+ return _CdiLib.cdiCopyKeys(cdiID1, varID1, cdiID2, varID2)
+CDI_KEY_XNAME = _CdiLib.CDI_KEY_XNAME
+CDI_KEY_XDIMNAME = _CdiLib.CDI_KEY_XDIMNAME
+CDI_KEY_XLONGNAME = _CdiLib.CDI_KEY_XLONGNAME
+CDI_KEY_XUNITS = _CdiLib.CDI_KEY_XUNITS
+CDI_KEY_YNAME = _CdiLib.CDI_KEY_YNAME
+CDI_KEY_YDIMNAME = _CdiLib.CDI_KEY_YDIMNAME
+CDI_KEY_YLONGNAME = _CdiLib.CDI_KEY_YLONGNAME
+CDI_KEY_YUNITS = _CdiLib.CDI_KEY_YUNITS
+CDI_KEY_VDIMNAME = _CdiLib.CDI_KEY_VDIMNAME
+CDI_KEY_MAPPING = _CdiLib.CDI_KEY_MAPPING
+CDI_KEY_MAPNAME = _CdiLib.CDI_KEY_MAPNAME
+CDI_KEY_NAME = _CdiLib.CDI_KEY_NAME
+CDI_KEY_DIMNAME = _CdiLib.CDI_KEY_DIMNAME
+CDI_KEY_LONGNAME = _CdiLib.CDI_KEY_LONGNAME
+CDI_KEY_UNITS = _CdiLib.CDI_KEY_UNITS
+CDI_KEY_PSNAME = _CdiLib.CDI_KEY_PSNAME
+CDI_KEY_P0NAME = _CdiLib.CDI_KEY_P0NAME
+CDI_KEY_P0VALUE = _CdiLib.CDI_KEY_P0VALUE
+
+def cdiGridDefKeyStr(gridID, key, size, mesg):
+ return _CdiLib.cdiGridDefKeyStr(gridID, key, size, mesg)
+
+def cdiGridInqKeyStr(gridID, key, size, mesg):
+ return _CdiLib.cdiGridInqKeyStr(gridID, key, size, mesg)
+
+def cdiZaxisDefKeyStr(zaxisID, key, size, mesg):
+ return _CdiLib.cdiZaxisDefKeyStr(zaxisID, key, size, mesg)
+
+def cdiZaxisInqKeyStr(zaxisID, key, size, mesg):
+ return _CdiLib.cdiZaxisInqKeyStr(zaxisID, key, size, mesg)
+
+def cdiZaxisDefKeyFlt(zaxisID, key, value):
+ return _CdiLib.cdiZaxisDefKeyFlt(zaxisID, key, value)
+
+def cdiZaxisInqKeyFlt(zaxisID, key, value):
+ return _CdiLib.cdiZaxisInqKeyFlt(zaxisID, key, value)
+
+def gridDefXname(gridID, xname):
+ return _CdiLib.gridDefXname(gridID, xname)
+
+def gridInqXname(gridID, xname):
+ return _CdiLib.gridInqXname(gridID, xname)
+
+def gridDefXlongname(gridID, xlongname):
+ return _CdiLib.gridDefXlongname(gridID, xlongname)
+
+def gridInqXlongname(gridID, xlongname):
+ return _CdiLib.gridInqXlongname(gridID, xlongname)
+
+def gridDefXunits(gridID, xunits):
+ return _CdiLib.gridDefXunits(gridID, xunits)
+
+def gridInqXunits(gridID, xunits):
+ return _CdiLib.gridInqXunits(gridID, xunits)
+
+def gridDefYname(gridID, yname):
+ return _CdiLib.gridDefYname(gridID, yname)
+
+def gridInqYname(gridID, yname):
+ return _CdiLib.gridInqYname(gridID, yname)
+
+def gridDefYlongname(gridID, ylongname):
+ return _CdiLib.gridDefYlongname(gridID, ylongname)
+
+def gridInqYlongname(gridID, ylongname):
+ return _CdiLib.gridInqYlongname(gridID, ylongname)
+
+def gridDefYunits(gridID, yunits):
+ return _CdiLib.gridDefYunits(gridID, yunits)
+
+def gridInqYunits(gridID, yunits):
+ return _CdiLib.gridInqYunits(gridID, yunits)
+
+def gridInqXstdname(gridID, xstdname):
+ return _CdiLib.gridInqXstdname(gridID, xstdname)
+
+def gridInqYstdname(gridID, ystdname):
+ return _CdiLib.gridInqYstdname(gridID, ystdname)
+
+def gridDefDatatype(gridID, prec):
+ return _CdiLib.gridDefDatatype(gridID, prec)
+
+def gridInqDatatype(gridID):
+ return _CdiLib.gridInqDatatype(gridID)
+
+def gridInqXval(gridID, index):
+ return _CdiLib.gridInqXval(gridID, index)
+
+def gridInqYval(gridID, index):
+ return _CdiLib.gridInqYval(gridID, index)
+
+def gridInqXinc(gridID):
+ return _CdiLib.gridInqXinc(gridID)
+
+def gridInqYinc(gridID):
+ return _CdiLib.gridInqYinc(gridID)
+
+def gridIsCircular(gridID):
+ return _CdiLib.gridIsCircular(gridID)
+
+def gridInqTrunc(gridID):
+ return _CdiLib.gridInqTrunc(gridID)
+
+def gridDefTrunc(gridID, trunc):
+ return _CdiLib.gridDefTrunc(gridID, trunc)
+
+def gridDefNumber(gridID, number):
+ return _CdiLib.gridDefNumber(gridID, number)
+
+def gridInqNumber(gridID):
+ return _CdiLib.gridInqNumber(gridID)
+
+def gridDefPosition(gridID, position):
+ return _CdiLib.gridDefPosition(gridID, position)
+
+def gridInqPosition(gridID):
+ return _CdiLib.gridInqPosition(gridID)
+
+def gridDefReference(gridID, reference):
+ return _CdiLib.gridDefReference(gridID, reference)
+
+def gridInqReference(gridID, reference):
+ return _CdiLib.gridInqReference(gridID, reference)
+
+def gridDefUUID(gridID, uuid):
+ return _CdiLib.gridDefUUID(gridID, uuid)
+
+def gridInqUUID(gridID, uuid):
+ return _CdiLib.gridInqUUID(gridID, uuid)
+
+def gridDefParamRLL(gridID, xpole, ypole, angle):
+ return _CdiLib.gridDefParamRLL(gridID, xpole, ypole, angle)
+
+def gridInqParamRLL(gridID, xpole, ypole, angle):
+ return _CdiLib.gridInqParamRLL(gridID, xpole, ypole, angle)
+
+def gridDefParamGME(gridID, nd, ni, ni2, ni3):
+ return _CdiLib.gridDefParamGME(gridID, nd, ni, ni2, ni3)
+
+def gridInqParamGME(gridID, nd, ni, ni2, ni3):
+ return _CdiLib.gridInqParamGME(gridID, nd, ni, ni2, ni3)
+
+def gridDefParamLCC(gridID, missval, lon_0, lat_0, lat_1, lat_2, a, rf, xval_0, yval_0, x_0, y_0):
+ return _CdiLib.gridDefParamLCC(gridID, missval, lon_0, lat_0, lat_1, lat_2, a, rf, xval_0, yval_0, x_0, y_0)
+
+def gridInqParamLCC(gridID, missval, lon_0, lat_0, lat_1, lat_2, a, rf, xval_0, yval_0, x_0, y_0):
+ return _CdiLib.gridInqParamLCC(gridID, missval, lon_0, lat_0, lat_1, lat_2, a, rf, xval_0, yval_0, x_0, y_0)
+
+def gridDefParamSTERE(gridID, missval, lon_0, lat_ts, lat_0, a, xval_0, yval_0, x_0, y_0):
+ return _CdiLib.gridDefParamSTERE(gridID, missval, lon_0, lat_ts, lat_0, a, xval_0, yval_0, x_0, y_0)
+
+def gridInqParamSTERE(gridID, missval, lon_0, lat_ts, lat_0, a, xval_0, yval_0, x_0, y_0):
+ return _CdiLib.gridInqParamSTERE(gridID, missval, lon_0, lat_ts, lat_0, a, xval_0, yval_0, x_0, y_0)
+
+def gridDefArea(gridID, area):
+ return _CdiLib.gridDefArea(gridID, area)
+
+def gridInqArea(gridID, area):
+ return _CdiLib.gridInqArea(gridID, area)
+
+def gridHasArea(gridID):
+ return _CdiLib.gridHasArea(gridID)
+
+def gridDefNvertex(gridID, nvertex):
+ return _CdiLib.gridDefNvertex(gridID, nvertex)
+
+def gridInqNvertex(gridID):
+ return _CdiLib.gridInqNvertex(gridID)
+
+def gridDefXbounds(gridID, xbounds):
+ return _CdiLib.gridDefXbounds(gridID, xbounds)
+
+def gridInqXbounds(gridID, xbounds):
+ return _CdiLib.gridInqXbounds(gridID, xbounds)
+
+def gridInqXboundsPart(gridID, start, size, xbounds):
+ return _CdiLib.gridInqXboundsPart(gridID, start, size, xbounds)
+
+def gridDefYbounds(gridID, ybounds):
+ return _CdiLib.gridDefYbounds(gridID, ybounds)
+
+def gridInqYbounds(gridID, ybounds):
+ return _CdiLib.gridInqYbounds(gridID, ybounds)
+
+def gridInqYboundsPart(gridID, start, size, ybounds):
+ return _CdiLib.gridInqYboundsPart(gridID, start, size, ybounds)
+
+def gridDefReducedPoints(gridID, reducedPointsSize, reducedPoints):
+ return _CdiLib.gridDefReducedPoints(gridID, reducedPointsSize, reducedPoints)
+
+def gridInqReducedPoints(gridID, reducedPoints):
+ return _CdiLib.gridInqReducedPoints(gridID, reducedPoints)
+
+def gridChangeType(gridID, gridtype):
+ return _CdiLib.gridChangeType(gridID, gridtype)
+
+def gridDefComplexPacking(gridID, lpack):
+ return _CdiLib.gridDefComplexPacking(gridID, lpack)
+
+def gridInqComplexPacking(gridID):
+ return _CdiLib.gridInqComplexPacking(gridID)
+
+def gridDefScanningMode(gridID, mode):
+ return _CdiLib.gridDefScanningMode(gridID, mode)
+
+def gridInqScanningMode(gridID):
+ return _CdiLib.gridInqScanningMode(gridID)
+
+def zaxisName(zaxistype, zaxisname):
+ return _CdiLib.zaxisName(zaxistype, zaxisname)
+
+def zaxisNamePtr(leveltype):
+ return _CdiLib.zaxisNamePtr(leveltype)
+
+def zaxisCreate(zaxistype, size):
+ return _CdiLib.zaxisCreate(zaxistype, size)
+
+def zaxisDestroy(zaxisID):
+ return _CdiLib.zaxisDestroy(zaxisID)
+
+def zaxisInqType(zaxisID):
+ return _CdiLib.zaxisInqType(zaxisID)
+
+def zaxisInqSize(zaxisID):
+ return _CdiLib.zaxisInqSize(zaxisID)
+
+def zaxisDuplicate(zaxisID):
+ return _CdiLib.zaxisDuplicate(zaxisID)
+
+def zaxisDefLevels(zaxisID, levels):
+ return _CdiLib.zaxisDefLevels(zaxisID, levels)
+
+def zaxisDefCvals(zaxisID, cvals, clength):
+ return _CdiLib.zaxisDefCvals(zaxisID, cvals, clength)
+
+def zaxisInqLevels(zaxisID, levels):
+ return _CdiLib.zaxisInqLevels(zaxisID, levels)
+
+def zaxisInqCLen(zaxisID):
+ return _CdiLib.zaxisInqCLen(zaxisID)
+
+def zaxisInqCVals(zaxisID, clevels):
+ return _CdiLib.zaxisInqCVals(zaxisID, clevels)
+
+def zaxisDefLevel(zaxisID, levelID, levels):
+ return _CdiLib.zaxisDefLevel(zaxisID, levelID, levels)
+
+def zaxisInqLevel(zaxisID, levelID):
+ return _CdiLib.zaxisInqLevel(zaxisID, levelID)
+
+def zaxisDefNlevRef(gridID, nhlev):
+ return _CdiLib.zaxisDefNlevRef(gridID, nhlev)
+
+def zaxisInqNlevRef(gridID):
+ return _CdiLib.zaxisInqNlevRef(gridID)
+
+def zaxisDefNumber(gridID, number):
+ return _CdiLib.zaxisDefNumber(gridID, number)
+
+def zaxisInqNumber(gridID):
+ return _CdiLib.zaxisInqNumber(gridID)
+
+def zaxisDefUUID(zaxisID, uuid):
+ return _CdiLib.zaxisDefUUID(zaxisID, uuid)
+
+def zaxisInqUUID(zaxisID, uuid):
+ return _CdiLib.zaxisInqUUID(zaxisID, uuid)
+
+def zaxisDefName(zaxisID, name_optional):
+ return _CdiLib.zaxisDefName(zaxisID, name_optional)
+
+def zaxisInqName(zaxisID, name):
+ return _CdiLib.zaxisInqName(zaxisID, name)
+
+def zaxisDefLongname(zaxisID, longname_optional):
+ return _CdiLib.zaxisDefLongname(zaxisID, longname_optional)
+
+def zaxisInqLongname(zaxisID, longname):
+ return _CdiLib.zaxisInqLongname(zaxisID, longname)
+
+def zaxisDefUnits(zaxisID, units_optional):
+ return _CdiLib.zaxisDefUnits(zaxisID, units_optional)
+
+def zaxisInqUnits(zaxisID, units):
+ return _CdiLib.zaxisInqUnits(zaxisID, units)
+
+def zaxisInqStdname(zaxisID, stdname):
+ return _CdiLib.zaxisInqStdname(zaxisID, stdname)
+
+def zaxisDefDatatype(zaxisID, prec):
+ return _CdiLib.zaxisDefDatatype(zaxisID, prec)
+
+def zaxisInqDatatype(zaxisID):
+ return _CdiLib.zaxisInqDatatype(zaxisID)
+
+def zaxisDefPositive(zaxisID, positive):
+ return _CdiLib.zaxisDefPositive(zaxisID, positive)
+
+def zaxisInqPositive(zaxisID):
+ return _CdiLib.zaxisInqPositive(zaxisID)
+
+def zaxisDefScalar(zaxisID):
+ return _CdiLib.zaxisDefScalar(zaxisID)
+
+def zaxisInqScalar(zaxisID):
+ return _CdiLib.zaxisInqScalar(zaxisID)
+
+def zaxisDefLtype(zaxisID, ltype):
+ return _CdiLib.zaxisDefLtype(zaxisID, ltype)
+
+def zaxisInqLtype(zaxisID):
+ return _CdiLib.zaxisInqLtype(zaxisID)
+
+def zaxisDefLtype2(zaxisID, ltype2):
+ return _CdiLib.zaxisDefLtype2(zaxisID, ltype2)
+
+def zaxisInqLtype2(zaxisID):
+ return _CdiLib.zaxisInqLtype2(zaxisID)
+
+def zaxisDefVct(zaxisID, size, vct):
+ return _CdiLib.zaxisDefVct(zaxisID, size, vct)
+
+def zaxisInqVct(zaxisID, vct):
+ return _CdiLib.zaxisInqVct(zaxisID, vct)
+
+def zaxisInqVctSize(zaxisID):
+ return _CdiLib.zaxisInqVctSize(zaxisID)
+
+def zaxisInqVctPtr(zaxisID):
+ return _CdiLib.zaxisInqVctPtr(zaxisID)
+
+def zaxisDefLbounds(zaxisID, lbounds):
+ return _CdiLib.zaxisDefLbounds(zaxisID, lbounds)
+
+def zaxisInqLbounds(zaxisID, lbounds_optional):
+ return _CdiLib.zaxisInqLbounds(zaxisID, lbounds_optional)
+
+def zaxisInqLbound(zaxisID, index):
+ return _CdiLib.zaxisInqLbound(zaxisID, index)
+
+def zaxisDefUbounds(zaxisID, ubounds):
+ return _CdiLib.zaxisDefUbounds(zaxisID, ubounds)
+
+def zaxisInqUbounds(zaxisID, ubounds_optional):
+ return _CdiLib.zaxisInqUbounds(zaxisID, ubounds_optional)
+
+def zaxisInqUbound(zaxisID, index):
+ return _CdiLib.zaxisInqUbound(zaxisID, index)
+
+def zaxisDefWeights(zaxisID, weights):
+ return _CdiLib.zaxisDefWeights(zaxisID, weights)
+
+def zaxisInqWeights(zaxisID, weights_optional):
+ return _CdiLib.zaxisInqWeights(zaxisID, weights_optional)
+
+def zaxisChangeType(zaxisID, zaxistype):
+ return _CdiLib.zaxisChangeType(zaxisID, zaxistype)
+
+def taxisCreate(taxistype):
+ return _CdiLib.taxisCreate(taxistype)
+
+def taxisDestroy(taxisID):
+ return _CdiLib.taxisDestroy(taxisID)
+
+def taxisDuplicate(taxisID):
+ return _CdiLib.taxisDuplicate(taxisID)
+
+def taxisCopyTimestep(taxisIDdes, taxisIDsrc):
+ return _CdiLib.taxisCopyTimestep(taxisIDdes, taxisIDsrc)
+
+def taxisDefType(taxisID, taxistype):
+ return _CdiLib.taxisDefType(taxisID, taxistype)
+
+def taxisInqType(taxisID):
+ return _CdiLib.taxisInqType(taxisID)
+
+def taxisDefVdate(taxisID, date):
+ return _CdiLib.taxisDefVdate(taxisID, date)
+
+def taxisDefVtime(taxisID, time):
+ return _CdiLib.taxisDefVtime(taxisID, time)
+
+def taxisInqVdate(taxisID):
+ return _CdiLib.taxisInqVdate(taxisID)
+
+def taxisInqVtime(taxisID):
+ return _CdiLib.taxisInqVtime(taxisID)
+
+def taxisDefRdate(taxisID, date):
+ return _CdiLib.taxisDefRdate(taxisID, date)
+
+def taxisDefRtime(taxisID, time):
+ return _CdiLib.taxisDefRtime(taxisID, time)
+
+def taxisInqRdate(taxisID):
+ return _CdiLib.taxisInqRdate(taxisID)
+
+def taxisInqRtime(taxisID):
+ return _CdiLib.taxisInqRtime(taxisID)
+
+def taxisDefFdate(taxisID, date):
+ return _CdiLib.taxisDefFdate(taxisID, date)
+
+def taxisDefFtime(taxisID, time):
+ return _CdiLib.taxisDefFtime(taxisID, time)
+
+def taxisInqFdate(taxisID):
+ return _CdiLib.taxisInqFdate(taxisID)
+
+def taxisInqFtime(taxisID):
+ return _CdiLib.taxisInqFtime(taxisID)
+
+def taxisHasBounds(taxisID):
+ return _CdiLib.taxisHasBounds(taxisID)
+
+def taxisWithBounds(taxisID):
+ return _CdiLib.taxisWithBounds(taxisID)
+
+def taxisDeleteBounds(taxisID):
+ return _CdiLib.taxisDeleteBounds(taxisID)
+
+def taxisDefVdateBounds(taxisID, vdate_lb, vdate_ub):
+ return _CdiLib.taxisDefVdateBounds(taxisID, vdate_lb, vdate_ub)
+
+def taxisDefVtimeBounds(taxisID, vtime_lb, vtime_ub):
+ return _CdiLib.taxisDefVtimeBounds(taxisID, vtime_lb, vtime_ub)
+
+def taxisInqVdateBounds(taxisID, vdate_lb, vdate_ub):
+ return _CdiLib.taxisInqVdateBounds(taxisID, vdate_lb, vdate_ub)
+
+def taxisInqVtimeBounds(taxisID, vtime_lb, vtime_ub):
+ return _CdiLib.taxisInqVtimeBounds(taxisID, vtime_lb, vtime_ub)
+
+def taxisDefCalendar(taxisID, calendar):
+ return _CdiLib.taxisDefCalendar(taxisID, calendar)
+
+def taxisInqCalendar(taxisID):
+ return _CdiLib.taxisInqCalendar(taxisID)
+
+def taxisDefTunit(taxisID, tunit):
+ return _CdiLib.taxisDefTunit(taxisID, tunit)
+
+def taxisInqTunit(taxisID):
+ return _CdiLib.taxisInqTunit(taxisID)
+
+def taxisDefForecastTunit(taxisID, tunit):
+ return _CdiLib.taxisDefForecastTunit(taxisID, tunit)
+
+def taxisInqForecastTunit(taxisID):
+ return _CdiLib.taxisInqForecastTunit(taxisID)
+
+def taxisDefForecastPeriod(taxisID, fc_period):
+ return _CdiLib.taxisDefForecastPeriod(taxisID, fc_period)
+
+def taxisInqForecastPeriod(taxisID):
+ return _CdiLib.taxisInqForecastPeriod(taxisID)
+
+def taxisDefNumavg(taxisID, numavg):
+ return _CdiLib.taxisDefNumavg(taxisID, numavg)
+
+def taxisInqNumavg(taxisID):
+ return _CdiLib.taxisInqNumavg(taxisID)
+
+def tunitNamePtr(tunitID):
+ return _CdiLib.tunitNamePtr(tunitID)
+
+def institutDef(center, subcenter, name, longname):
+ return _CdiLib.institutDef(center, subcenter, name, longname)
+
+def institutInq(center, subcenter, name, longname):
+ return _CdiLib.institutInq(center, subcenter, name, longname)
+
+def institutInqNumber():
+ return _CdiLib.institutInqNumber()
+
+def institutInqCenter(instID):
+ return _CdiLib.institutInqCenter(instID)
+
+def institutInqSubcenter(instID):
+ return _CdiLib.institutInqSubcenter(instID)
+
+def institutInqNamePtr(instID):
+ return _CdiLib.institutInqNamePtr(instID)
+
+def institutInqLongnamePtr(instID):
+ return _CdiLib.institutInqLongnamePtr(instID)
+
+def modelDef(instID, modelgribID, name):
+ return _CdiLib.modelDef(instID, modelgribID, name)
+
+def modelInq(instID, modelgribID, name):
+ return _CdiLib.modelInq(instID, modelgribID, name)
+
+def modelInqInstitut(modelID):
+ return _CdiLib.modelInqInstitut(modelID)
+
+def modelInqGribID(modelID):
+ return _CdiLib.modelInqGribID(modelID)
+
+def modelInqNamePtr(modelID):
+ return _CdiLib.modelInqNamePtr(modelID)
+
+def tableFWriteC(ptfp, tableID):
+ return _CdiLib.tableFWriteC(ptfp, tableID)
+
+def tableWrite(filename, tableID):
+ return _CdiLib.tableWrite(filename, tableID)
+
+def tableRead(tablefile):
+ return _CdiLib.tableRead(tablefile)
+
+def tableDef(modelID, tablenum, tablename):
+ return _CdiLib.tableDef(modelID, tablenum, tablename)
+
+def tableInqNamePtr(tableID):
+ return _CdiLib.tableInqNamePtr(tableID)
+
+def tableInq(modelID, tablenum, tablename):
+ return _CdiLib.tableInq(modelID, tablenum, tablename)
+
+def tableInqNumber():
+ return _CdiLib.tableInqNumber()
+
+def tableInqNum(tableID):
+ return _CdiLib.tableInqNum(tableID)
+
+def tableInqModel(tableID):
+ return _CdiLib.tableInqModel(tableID)
+
+def tableInqEntry(tableID, id, ltype, name, longname, units):
+ return _CdiLib.tableInqEntry(tableID, id, ltype, name, longname, units)
+
+def streamDefHistory(streamID, size, history):
+ return _CdiLib.streamDefHistory(streamID, size, history)
+
+def streamInqHistorySize(streamID):
+ return _CdiLib.streamInqHistorySize(streamID)
+
+def streamInqHistoryString(streamID, history):
+ return _CdiLib.streamInqHistoryString(streamID, history)
+
+def subtypeCreate(subtype):
+ return _CdiLib.subtypeCreate(subtype)
+
+def subtypePrint(subtypeID):
+ return _CdiLib.subtypePrint(subtypeID)
+
+def subtypeCompare(subtypeID1, subtypeID2):
+ return _CdiLib.subtypeCompare(subtypeID1, subtypeID2)
+
+def subtypeInqSize(subtypeID):
+ return _CdiLib.subtypeInqSize(subtypeID)
+
+def subtypeInqActiveIndex(subtypeID):
+ return _CdiLib.subtypeInqActiveIndex(subtypeID)
+
+def subtypeDefActiveIndex(subtypeID, index):
+ return _CdiLib.subtypeDefActiveIndex(subtypeID, index)
+
+def keyValuePair(key, value):
+ return _CdiLib.keyValuePair(key, value)
+
+def matchAND(q1, q2):
+ return _CdiLib.matchAND(q1, q2)
+
+def subtypeInqSubEntry(subtypeID, criterion):
+ return _CdiLib.subtypeInqSubEntry(subtypeID, criterion)
+
+def subtypeInqTile(subtypeID, tileindex, attribute):
+ return _CdiLib.subtypeInqTile(subtypeID, tileindex, attribute)
+
+def subtypeInqAttribute(subtypeID, index, key, outValue):
+ return _CdiLib.subtypeInqAttribute(subtypeID, index, key, outValue)
+
+def vlistInqVarSubtype(vlistID, varID):
+ return _CdiLib.vlistInqVarSubtype(vlistID, varID)
+
+def gribapiLibraryVersion(major_version, minor_version, revision_version):
+ return _CdiLib.gribapiLibraryVersion(major_version, minor_version, revision_version)
+
+def gaussianLatitudes(latitudes, weights, nlat):
+ return _CdiLib.gaussianLatitudes(latitudes, weights, nlat)
diff --git a/interfaces/python/cdilib_wrap.c b/interfaces/python/cdilib_wrap.c
index 85a9cf697..ba9cba727 100644
--- a/interfaces/python/cdilib_wrap.c
+++ b/interfaces/python/cdilib_wrap.c
@@ -1,15 +1,20 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.36
- *
- * This file is not intended to be easily readable and contains a number of
+ * Version 4.0.0
+ *
+ * This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
* ----------------------------------------------------------------------------- */
+
+#ifndef SWIGPYTHON
#define SWIGPYTHON
+#endif
+
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
+
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
@@ -41,28 +46,28 @@
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
-# define SWIGUNUSED
+# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif
+# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
-# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
@@ -77,9 +82,11 @@
#endif
/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-# ifndef GCC_HASCLASSVISIBILITY
-# define GCC_HASCLASSVISIBILITY
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
# endif
#endif
@@ -105,7 +112,7 @@
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
-# endif
+# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
@@ -118,15 +125,39 @@
# define _SCL_SECURE_NO_DEPRECATE
#endif
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used. So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
-/* Python.h has to appear first */
-#include <Python.h>
+#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
+/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
+# include <math.h>
+#endif
+
+#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
+/* Use debug wrappers with the Python release dll */
+# undef _DEBUG
+# include <Python.h>
+# define _DEBUG 1
+#else
+# include <Python.h>
+#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
@@ -145,11 +176,11 @@
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
- creating a static or dynamic library from the swig runtime code.
- In 99.9% of the cases, swig just needs to declare them as 'static'.
-
- But only do this if is strictly necessary, ie, if you have problems
- with your compiler or so.
+ creating a static or dynamic library from the SWIG runtime code.
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+ But only do this if strictly necessary, ie, if you have problems
+ with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
@@ -168,22 +199,23 @@
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
+#define SWIG_POINTER_NO_NULL 0x4
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
-/*
+/*
Flags/methods for returning states.
-
- The swig conversion methods, as ConvertPtr, return and integer
+
+ The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
-
+
Use the following macros/flags to set or process the returning
states.
-
- In old swig versions, you usually write code as:
+
+ In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
@@ -191,7 +223,7 @@
//fail code
}
- Now you can be more explicit as:
+ Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
@@ -200,7 +232,7 @@
// fail code
}
- that seems to be the same, but now you can also do
+ which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -215,28 +247,28 @@
} else {
// fail code
}
-
+
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
- requires also to SWIG_ConvertPtr to return new result values, as
-
- int SWIG_ConvertPtr(obj, ptr,...) {
- if (<obj is ok>) {
- if (<need new object>) {
- *ptr = <ptr to new allocated object>;
- return SWIG_NEWOBJ;
- } else {
- *ptr = <ptr to old object>;
- return SWIG_OLDOBJ;
- }
- } else {
- return SWIG_BADOBJ;
- }
+ also requires SWIG_ConvertPtr to return new result values, such as
+
+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
- swig errors code.
+ SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
@@ -245,18 +277,17 @@
int fooi(int);
and you call
-
+
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
+*/
-
- */
-#define SWIG_OK (0)
+#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
-#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
@@ -277,7 +308,6 @@
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
@@ -288,20 +318,18 @@
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
-SWIGINTERNINLINE int SWIG_AddCast(int r) {
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
-SWIGINTERNINLINE int SWIG_CheckState(int r) {
- return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
-# define SWIG_AddCast
+# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
-
-
#include <string.h>
#ifdef __cplusplus
@@ -341,7 +369,7 @@ typedef struct swig_module_info {
void *clientdata; /* Language specific module data */
} swig_module_info;
-/*
+/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
@@ -361,18 +389,18 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
/*
Check type equivalence in a name list like <name1>|<name2>|...
- Return 0 if not equal, 1 if equal
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
-SWIG_TypeEquiv(const char *nb, const char *tb) {
- int equiv = 0;
+SWIG_TypeCmp(const char *nb, const char *tb) {
+ int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
- while (!equiv && *ne) {
+ while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
@@ -380,58 +408,65 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
/*
Check type equivalence in a name list like <name1>|<name2>|...
- Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+ Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
-SWIG_TypeCompare(const char *nb, const char *tb) {
- int equiv = 0;
- const char* te = tb + strlen(tb);
- const char* ne = nb;
- while (!equiv && *ne) {
- for (nb = ne; *ne; ++ne) {
- if (*ne == '|') break;
- }
- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
- if (*ne) ++ne;
- }
- return equiv;
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
-
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty) \
- if (ty) { \
- swig_cast_info *iter = ty->cast; \
- while (iter) { \
- if (comparison) { \
- if (iter == ty->cast) return iter; \
- /* Move iter to the top of the linked list */ \
- iter->prev->next = iter->next; \
- if (iter->next) \
- iter->next->prev = iter->prev; \
- iter->next = ty->cast; \
- iter->prev = 0; \
- if (ty->cast) ty->cast->prev = iter; \
- ty->cast = iter; \
- return iter; \
- } \
- iter = iter->next; \
- } \
- } \
- return 0
-
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(iter->type->name, c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/*
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
- SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (iter->type == from) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
/*
@@ -442,7 +477,7 @@ SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
-/*
+/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
@@ -486,7 +521,7 @@ SWIG_TypePrettyName(const swig_type_info *type) {
return type->name;
}
-/*
+/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
@@ -494,14 +529,14 @@ SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
-
+
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
- }
+ }
cast = cast->next;
}
}
@@ -510,31 +545,31 @@ SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
-
+
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
-
- We start searching at module start, and finish searching when start == end.
+
+ We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
-SWIG_MangledTypeQueryModule(swig_module_info *start,
- swig_module_info *end,
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
- register size_t l = 0;
- register size_t r = iter->size - 1;
+ size_t l = 0;
+ size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
- register size_t i = (l + r) >> 1;
+ size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
- register int compare = strcmp(name, iname);
- if (compare == 0) {
+ int compare = strcmp(name, iname);
+ if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
@@ -559,14 +594,14 @@ SWIG_MangledTypeQueryModule(swig_module_info *start,
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
-
- We start searching at module start, and finish searching when start == end.
+
+ We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
-SWIG_TypeQueryModule(swig_module_info *start,
- swig_module_info *end,
+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
@@ -577,7 +612,7 @@ SWIG_TypeQueryModule(swig_module_info *start,
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
- register size_t i = 0;
+ size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
@@ -585,56 +620,56 @@ SWIG_TypeQueryModule(swig_module_info *start,
iter = iter->next;
} while (iter != end);
}
-
+
/* neither found a match */
return 0;
}
-/*
+/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
- register const unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
-/*
+/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
- register unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
- uu = ((d - '0') << 4);
+ uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
- uu = ((d - ('a'-10)) << 4);
- else
+ uu = (unsigned char)((d - ('a'-10)) << 4);
+ else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
- uu |= (d - '0');
+ uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
- uu |= (d - ('a'-10));
- else
+ uu |= (unsigned char)(d - ('a'-10));
+ else
return (char *) 0;
*u = uu;
}
return c;
}
-/*
+/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
@@ -694,109 +729,108 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
#endif
/* Errors in SWIG */
-#define SWIG_UnknownError -1
-#define SWIG_IOError -2
-#define SWIG_RuntimeError -3
-#define SWIG_IndexError -4
-#define SWIG_TypeError -5
-#define SWIG_DivisionByZero -6
-#define SWIG_OverflowError -7
-#define SWIG_SyntaxError -8
-#define SWIG_ValueError -9
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
-#define SWIG_MemoryError -12
+#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
+/* Compatibility macros for Python 3 */
+#if PY_VERSION_HEX >= 0x03000000
-/* Add PyOS_snprintf for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
-# define PyOS_snprintf _snprintf
-# else
-# define PyOS_snprintf snprintf
-# endif
-#endif
-
-/* A crude PyString_FromFormat implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
+#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
+#define PyInt_Check(x) PyLong_Check(x)
+#define PyInt_AsLong(x) PyLong_AsLong(x)
+#define PyInt_FromLong(x) PyLong_FromLong(x)
+#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
+#define PyString_Check(name) PyBytes_Check(name)
+#define PyString_FromString(x) PyUnicode_FromString(x)
+#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
+#define PyString_AsString(str) PyBytes_AsString(str)
+#define PyString_Size(str) PyBytes_Size(str)
+#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
+#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
+#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
+#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
-#ifndef SWIG_PYBUFFER_SIZE
-# define SWIG_PYBUFFER_SIZE 1024
#endif
-static PyObject *
-PyString_FromFormat(const char *fmt, ...) {
- va_list ap;
- char buf[SWIG_PYBUFFER_SIZE * 2];
- int res;
- va_start(ap, fmt);
- res = vsnprintf(buf, sizeof(buf), fmt, ap);
- va_end(ap);
- return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
-}
+#ifndef Py_TYPE
+# define Py_TYPE(op) ((op)->ob_type)
#endif
-/* Add PyObject_Del for old Pythons */
-#if PY_VERSION_HEX < 0x01060000
-# define PyObject_Del(op) PyMem_DEL((op))
-#endif
-#ifndef PyObject_DEL
-# define PyObject_DEL PyObject_Del
-#endif
+/* SWIG APIs for compatibility of both Python 2 & 3 */
-/* A crude PyExc_StopIteration exception for old Pythons */
-#if PY_VERSION_HEX < 0x02020000
-# ifndef PyExc_StopIteration
-# define PyExc_StopIteration PyExc_RuntimeError
-# endif
-# ifndef PyObject_GenericGetAttr
-# define PyObject_GenericGetAttr 0
-# endif
-#endif
-/* Py_NotImplemented is defined in 2.1 and up. */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef Py_NotImplemented
-# define Py_NotImplemented PyExc_RuntimeError
-# endif
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
+#else
+# define SWIG_Python_str_FromFormat PyString_FromFormat
#endif
-/* A crude PyString_AsStringAndSize implementation for old Pythons */
-#if PY_VERSION_HEX < 0x02010000
-# ifndef PyString_AsStringAndSize
-# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
-# endif
+/* Warning: This function will allocate a new string in Python 3,
+ * so please call SWIG_Python_str_DelForPy3(x) to free the space.
+ */
+SWIGINTERN char*
+SWIG_Python_str_AsChar(PyObject *str)
+{
+#if PY_VERSION_HEX >= 0x03000000
+ char *newstr = 0;
+ str = PyUnicode_AsUTF8String(str);
+ if (str) {
+ char *cstr;
+ Py_ssize_t len;
+ PyBytes_AsStringAndSize(str, &cstr, &len);
+ newstr = (char *) malloc(len+1);
+ memcpy(newstr, cstr, len+1);
+ Py_XDECREF(str);
+ }
+ return newstr;
+#else
+ return PyString_AsString(str);
#endif
+}
-/* PySequence_Size for old Pythons */
-#if PY_VERSION_HEX < 0x02000000
-# ifndef PySequence_Size
-# define PySequence_Size PySequence_Length
-# endif
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
+#else
+# define SWIG_Python_str_DelForPy3(x)
#endif
-/* PyBool_FromLong for old Pythons */
-#if PY_VERSION_HEX < 0x02030000
-static
-PyObject *PyBool_FromLong(long ok)
+SWIGINTERN PyObject*
+SWIG_Python_str_FromChar(const char *c)
{
- PyObject *result = ok ? Py_True : Py_False;
- Py_INCREF(result);
- return result;
+#if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_FromString(c);
+#else
+ return PyString_FromString(c);
+#endif
}
+
+#ifndef PyObject_DEL
+# define PyObject_DEL PyObject_Del
#endif
-/* Py_ssize_t for old Pythons */
-/* This code is as recommended by: */
-/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
-#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
-typedef int Py_ssize_t;
-# define PY_SSIZE_T_MAX INT_MAX
-# define PY_SSIZE_T_MIN INT_MIN
+// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
+// interface files check for it.
+# define SWIGPY_USE_CAPSULE
+# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
+
+#if PY_VERSION_HEX < 0x03020000
+#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
+#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
+#define Py_hash_t long
#endif
/* -----------------------------------------------------------------------------
@@ -854,12 +888,18 @@ SWIG_Python_AddErrorMsg(const char* mesg)
PyObject *value = 0;
PyObject *traceback = 0;
- if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
+ if (PyErr_Occurred())
+ PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
+ const char *tmp = SWIG_Python_str_AsChar(old_str);
PyErr_Clear();
Py_XINCREF(type);
- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+ if (tmp)
+ PyErr_Format(type, "%s %s", tmp, mesg);
+ else
+ PyErr_Format(type, "%s", mesg);
+ SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
Py_DECREF(value);
} else {
@@ -867,7 +907,36 @@ SWIG_Python_AddErrorMsg(const char* mesg)
}
}
+SWIGRUNTIME int
+SWIG_Python_TypeErrorOccurred(PyObject *obj)
+{
+ PyObject *error;
+ if (obj)
+ return 0;
+ error = PyErr_Occurred();
+ return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
+}
+SWIGRUNTIME void
+SWIG_Python_RaiseOrModifyTypeError(const char *message)
+{
+ if (SWIG_Python_TypeErrorOccurred(NULL)) {
+ /* Use existing TypeError to preserve stacktrace and enhance with given message */
+ PyObject *newvalue;
+ PyObject *type = NULL, *value = NULL, *traceback = NULL;
+ PyErr_Fetch(&type, &value, &traceback);
+#if PY_VERSION_HEX >= 0x03000000
+ newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
+#else
+ newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
+#endif
+ Py_XDECREF(value);
+ PyErr_Restore(type, newvalue, traceback);
+ } else {
+ /* Raise TypeError using given message */
+ PyErr_SetString(PyExc_TypeError, message);
+ }
+}
#if defined(SWIG_PYTHON_NO_THREADS)
# if defined(SWIG_PYTHON_THREADS)
@@ -876,9 +945,7 @@ SWIG_Python_AddErrorMsg(const char* mesg)
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
-# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
-# define SWIG_PYTHON_USE_GIL
-# endif
+# define SWIG_PYTHON_USE_GIL
# endif
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
@@ -942,9 +1009,6 @@ SWIG_Python_AddErrorMsg(const char* mesg)
#ifdef __cplusplus
extern "C" {
-#if 0
-} /* cc-mode */
-#endif
#endif
/* -----------------------------------------------------------------------------
@@ -958,7 +1022,7 @@ extern "C" {
/* Constant information structure */
typedef struct swig_const_info {
int type;
- char *name;
+ const char *name;
long lvalue;
double dvalue;
void *pvalue;
@@ -966,17 +1030,11 @@ typedef struct swig_const_info {
} swig_const_info;
#ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
}
#endif
/* -----------------------------------------------------------------------------
- * See the LICENSE file for information on copyright, usage and redistribution
- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
- *
* pyrun.swg
*
* This file contains the runtime support for Python modules
@@ -985,13 +1043,29 @@ typedef struct swig_const_info {
*
* ----------------------------------------------------------------------------- */
+#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
+# error "This version of SWIG only supports Python >= 2.7"
+#endif
+
+#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
+# error "This version of SWIG only supports Python 3 >= 3.2"
+#endif
+
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
-#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
+
+#ifdef SWIGPYTHON_BUILTIN
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
+#else
+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
+#endif
+
+#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
+
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
@@ -1006,7 +1080,7 @@ typedef struct swig_const_info {
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
-#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
@@ -1015,9 +1089,9 @@ typedef struct swig_const_info {
/* Runtime API */
-#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
+#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
-#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
+#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
@@ -1041,7 +1115,7 @@ SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
- PyErr_SetString(errtype, (char *) msg);
+ PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
@@ -1049,17 +1123,37 @@ SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
/* Set a constant value */
+#if defined(SWIGPYTHON_BUILTIN)
+
+SWIGINTERN void
+SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
+ PyObject *s = PyString_InternFromString(key);
+ PyList_Append(seq, s);
+ Py_DECREF(s);
+}
+
+SWIGINTERN void
+SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
+ PyDict_SetItemString(d, name, obj);
+ Py_DECREF(obj);
+ if (public_interface)
+ SwigPyBuiltin_AddPublicSymbol(public_interface, name);
+}
+
+#else
+
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
- PyDict_SetItemString(d, (char*) name, obj);
+ PyDict_SetItemString(d, name, obj);
Py_DECREF(obj);
}
+#endif
+
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
-#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
if (!result) {
result = obj;
} else if (result == Py_None) {
@@ -1075,34 +1169,11 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
Py_DECREF(obj);
}
return result;
-#else
- PyObject* o2;
- PyObject* o3;
- if (!result) {
- result = obj;
- } else if (result == Py_None) {
- Py_DECREF(result);
- result = obj;
- } else {
- if (!PyTuple_Check(result)) {
- o2 = result;
- result = PyTuple_New(1);
- PyTuple_SET_ITEM(result, 0, o2);
- }
- o3 = PyTuple_New(1);
- PyTuple_SET_ITEM(o3, 0, obj);
- o2 = result;
- result = PySequence_Concat(o2, o3);
- Py_DECREF(o2);
- Py_DECREF(o3);
- }
- return result;
-#endif
}
/* Unpack the argument tuple */
-SWIGINTERN int
+SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
@@ -1115,10 +1186,18 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
}
}
if (!PyTuple_Check(args)) {
+ if (min <= 1 && max >= 1) {
+ Py_ssize_t i;
+ objs[0] = args;
+ for (i = 1; i < max; ++i) {
+ objs[i] = 0;
+ }
+ return 2;
+ }
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
- register Py_ssize_t l = PyTuple_GET_SIZE(args);
+ Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
@@ -1128,7 +1207,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
- register int i;
+ Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
@@ -1141,11 +1220,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
}
/* A functor is a function object with one single object argument */
-#if PY_VERSION_HEX >= 0x02020000
-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
-#else
-#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
-#endif
+#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, (char *)"O", obj);
/*
Helper for static pointer initialization for both C and C++ code, for example
@@ -1167,40 +1242,11 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
+#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
+#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
+
#ifdef __cplusplus
extern "C" {
-#if 0
-} /* cc-mode */
-#endif
-#endif
-
-/* How to access Py_None */
-#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-# ifndef SWIG_PYTHON_NO_BUILD_NONE
-# ifndef SWIG_PYTHON_BUILD_NONE
-# define SWIG_PYTHON_BUILD_NONE
-# endif
-# endif
-#endif
-
-#ifdef SWIG_PYTHON_BUILD_NONE
-# ifdef Py_None
-# undef Py_None
-# define Py_None SWIG_Py_None()
-# endif
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_Py_None(void)
-{
- PyObject *none = Py_BuildValue((char*)"");
- Py_DECREF(none);
- return none;
-}
-SWIGRUNTIME PyObject *
-SWIG_Py_None(void)
-{
- static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
- return none;
-}
#endif
/* The python void return value */
@@ -1213,7 +1259,7 @@ SWIG_Py_Void(void)
return none;
}
-/* PySwigClientData */
+/* SwigPyClientData */
typedef struct {
PyObject *klass;
@@ -1222,30 +1268,34 @@ typedef struct {
PyObject *destroy;
int delargs;
int implicitconv;
-} PySwigClientData;
+ PyTypeObject *pytype;
+} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
- PySwigClientData *data = (PySwigClientData *)ty->clientdata;
- return data ? data->implicitconv : 0;
+ SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
+ int fail = data ? data->implicitconv : 0;
+ if (fail)
+ PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
+ return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
- PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
+ SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
-SWIGRUNTIME PySwigClientData *
-PySwigClientData_New(PyObject* obj)
+SWIGRUNTIME SwigPyClientData *
+SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
- PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
+ SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
Py_INCREF(data->klass);
@@ -1255,11 +1305,7 @@ PySwigClientData_New(PyObject* obj)
data->newargs = obj;
Py_INCREF(obj);
} else {
-#if (PY_VERSION_HEX < 0x02020000)
- data->newraw = 0;
-#else
- data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
-#endif
+ data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
Py_INCREF(data->newraw);
data->newargs = PyTuple_New(1);
@@ -1270,7 +1316,7 @@ PySwigClientData_New(PyObject* obj)
Py_INCREF(data->newargs);
}
/* the destroy method, aka as the C++ delete method */
- data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
+ data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
@@ -1279,28 +1325,24 @@ PySwigClientData_New(PyObject* obj)
int flags;
Py_INCREF(data->destroy);
flags = PyCFunction_GET_FLAGS(data->destroy);
-#ifdef METH_O
data->delargs = !(flags & (METH_O));
-#else
- data->delargs = 0;
-#endif
} else {
data->delargs = 0;
}
data->implicitconv = 0;
+ data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
-PySwigClientData_Del(PySwigClientData* data)
-{
+SwigPyClientData_Del(SwigPyClientData *data) {
Py_XDECREF(data->newraw);
Py_XDECREF(data->newargs);
Py_XDECREF(data->destroy);
}
-/* =============== PySwigObject =====================*/
+/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
@@ -1308,24 +1350,48 @@ typedef struct {
swig_type_info *ty;
int own;
PyObject *next;
-} PySwigObject;
+#ifdef SWIGPYTHON_BUILTIN
+ PyObject *dict;
+#endif
+} SwigPyObject;
+
+
+#ifdef SWIGPYTHON_BUILTIN
+
+SWIGRUNTIME PyObject *
+SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
+{
+ SwigPyObject *sobj = (SwigPyObject *)v;
+
+ if (!sobj->dict)
+ sobj->dict = PyDict_New();
+
+ Py_INCREF(sobj->dict);
+ return sobj->dict;
+}
+
+#endif
SWIGRUNTIME PyObject *
-PySwigObject_long(PySwigObject *v)
+SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
-PySwigObject_format(const char* fmt, PySwigObject *v)
+SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
- if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
- PyObject *ofmt = PyString_FromString(fmt);
+ if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
+ PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
if (ofmt) {
+#if PY_VERSION_HEX >= 0x03000000
+ res = PyUnicode_Format(ofmt,args);
+#else
res = PyString_Format(ofmt,args);
+#endif
Py_DECREF(ofmt);
}
Py_DECREF(args);
@@ -1335,111 +1401,141 @@ PySwigObject_format(const char* fmt, PySwigObject *v)
}
SWIGRUNTIME PyObject *
-PySwigObject_oct(PySwigObject *v)
+SwigPyObject_oct(SwigPyObject *v)
{
- return PySwigObject_format("%o",v);
+ return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
-PySwigObject_hex(PySwigObject *v)
+SwigPyObject_hex(SwigPyObject *v)
{
- return PySwigObject_format("%x",v);
+ return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
-#ifdef METH_NOARGS
-PySwigObject_repr(PySwigObject *v)
-#else
-PySwigObject_repr(PySwigObject *v, PyObject *args)
-#endif
+SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
- PyObject *hex = PySwigObject_hex(v);
- PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
- Py_DECREF(hex);
+ PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
if (v->next) {
-#ifdef METH_NOARGS
- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
-#else
- PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
-#endif
+ PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
+# if PY_VERSION_HEX >= 0x03000000
+ PyObject *joined = PyUnicode_Concat(repr, nrep);
+ Py_DecRef(repr);
+ Py_DecRef(nrep);
+ repr = joined;
+# else
PyString_ConcatAndDel(&repr,nrep);
+# endif
}
return repr;
}
-SWIGRUNTIME int
-PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
-#ifdef METH_NOARGS
- PyObject *repr = PySwigObject_repr(v);
-#else
- PyObject *repr = PySwigObject_repr(v, NULL);
-#endif
- if (repr) {
- fputs(PyString_AsString(repr), fp);
- Py_DECREF(repr);
- return 0;
- } else {
- return 1;
- }
-}
-
+/* We need a version taking two PyObject* parameters so it's a valid
+ * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
-PySwigObject_str(PySwigObject *v)
+SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
- char result[SWIG_BUFFER_SIZE];
- return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
- PyString_FromString(result) : 0;
+ return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
-PySwigObject_compare(PySwigObject *v, PySwigObject *w)
+SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
void *i = v->ptr;
void *j = w->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
-SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
+/* Added for Python 3.x, would it also be useful for Python 2.x? */
+SWIGRUNTIME PyObject*
+SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
+{
+ PyObject* res;
+ if( op != Py_EQ && op != Py_NE ) {
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+ }
+ res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
+ return res;
+}
+
+SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
+
+#ifdef SWIGPYTHON_BUILTIN
+static swig_type_info *SwigPyObject_stype = 0;
+SWIGRUNTIME PyTypeObject*
+SwigPyObject_type(void) {
+ SwigPyClientData *cd;
+ assert(SwigPyObject_stype);
+ cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
+ assert(cd);
+ assert(cd->pytype);
+ return cd->pytype;
+}
+#else
SWIGRUNTIME PyTypeObject*
-PySwigObject_type(void) {
- static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
+SwigPyObject_type(void) {
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
+#endif
SWIGRUNTIMEINLINE int
-PySwigObject_Check(PyObject *op) {
- return ((op)->ob_type == PySwigObject_type())
- || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
+SwigPyObject_Check(PyObject *op) {
+#ifdef SWIGPYTHON_BUILTIN
+ PyTypeObject *target_tp = SwigPyObject_type();
+ if (PyType_IsSubtype(op->ob_type, target_tp))
+ return 1;
+ return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
+#else
+ return (Py_TYPE(op) == SwigPyObject_type())
+ || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
+#endif
}
SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own);
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
SWIGRUNTIME void
-PySwigObject_dealloc(PyObject *v)
+SwigPyObject_dealloc(PyObject *v)
{
- PySwigObject *sobj = (PySwigObject *) v;
+ SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
+ SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
+
+ /* PyObject_CallFunction() has the potential to silently drop
+ the active exception. In cases of unnamed temporary
+ variable or where we just finished iterating over a generator
+ StopIteration will be active right now, and this needs to
+ remain true upon return from SwigPyObject_dealloc. So save
+ and restore. */
+
+ PyObject *type = NULL, *value = NULL, *traceback = NULL;
+ PyErr_Fetch(&type, &value, &traceback);
+
if (data->delargs) {
- /* we need to create a temporal object to carry the destroy operation */
- PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
- res = SWIG_Python_CallFunctor(destroy, tmp);
- Py_DECREF(tmp);
+ /* we need to create a temporary object to carry the destroy operation */
+ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
+ res = SWIG_Python_CallFunctor(destroy, tmp);
+ Py_DECREF(tmp);
} else {
- PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
- PyObject *mself = PyCFunction_GET_SELF(destroy);
- res = ((*meth)(mself, v));
+ PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+ PyObject *mself = PyCFunction_GET_SELF(destroy);
+ res = ((*meth)(mself, v));
}
+ if (!res)
+ PyErr_WriteUnraisable(destroy);
+
+ PyErr_Restore(type, value, traceback);
+
Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
@@ -1454,15 +1550,11 @@ PySwigObject_dealloc(PyObject *v)
}
SWIGRUNTIME PyObject*
-PySwigObject_append(PyObject* v, PyObject* next)
+SwigPyObject_append(PyObject* v, PyObject* next)
{
- PySwigObject *sobj = (PySwigObject *) v;
-#ifndef METH_O
- PyObject *tmp = 0;
- if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
- next = tmp;
-#endif
- if (!PySwigObject_Check(next)) {
+ SwigPyObject *sobj = (SwigPyObject *) v;
+ if (!SwigPyObject_Check(next)) {
+ PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
sobj->next = next;
@@ -1471,13 +1563,9 @@ PySwigObject_append(PyObject* v, PyObject* next)
}
SWIGRUNTIME PyObject*
-#ifdef METH_NOARGS
-PySwigObject_next(PyObject* v)
-#else
-PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
+SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
- PySwigObject *sobj = (PySwigObject *) v;
+ SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
Py_INCREF(sobj->next);
return sobj->next;
@@ -1487,105 +1575,64 @@ PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
}
SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-PySwigObject_disown(PyObject *v)
-#else
-PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
+SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
- PySwigObject *sobj = (PySwigObject *)v;
+ SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
-#ifdef METH_NOARGS
-PySwigObject_acquire(PyObject *v)
-#else
-PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
-#endif
+SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
- PySwigObject *sobj = (PySwigObject *)v;
+ SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
-PySwigObject_own(PyObject *v, PyObject *args)
+SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
-#if (PY_VERSION_HEX < 0x02020000)
- if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
-#else
- if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
-#endif
- {
- return NULL;
+ if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
+ return NULL;
+ } else {
+ SwigPyObject *sobj = (SwigPyObject *)v;
+ PyObject *obj = PyBool_FromLong(sobj->own);
+ if (val) {
+ if (PyObject_IsTrue(val)) {
+ SwigPyObject_acquire(v,args);
+ } else {
+ SwigPyObject_disown(v,args);
+ }
}
- else
- {
- PySwigObject *sobj = (PySwigObject *)v;
- PyObject *obj = PyBool_FromLong(sobj->own);
- if (val) {
-#ifdef METH_NOARGS
- if (PyObject_IsTrue(val)) {
- PySwigObject_acquire(v);
- } else {
- PySwigObject_disown(v);
- }
-#else
- if (PyObject_IsTrue(val)) {
- PySwigObject_acquire(v,args);
- } else {
- PySwigObject_disown(v,args);
- }
-#endif
- }
- return obj;
- }
+ return obj;
+ }
}
-#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
+ {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
+ {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
+ {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
+ {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
+ {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
+ {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
-#else
-static PyMethodDef
-swigobject_methods[] = {
- {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
- {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
- {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
- {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
- {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
- {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
- {0, 0, 0, 0}
-};
-#endif
-
-#if PY_VERSION_HEX < 0x02020000
-SWIGINTERN PyObject *
-PySwigObject_getattr(PySwigObject *sobj,char *name)
-{
- return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
-}
-#endif
SWIGRUNTIME PyTypeObject*
-_PySwigObject_type(void) {
+SwigPyObject_TypeOnce(void) {
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
-
- static PyNumberMethods PySwigObject_as_number = {
+
+ static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
+ /* nb_divide removed in Python 3 */
+#if PY_VERSION_HEX < 0x03000000
(binaryfunc)0, /*nb_divide*/
+#endif
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
@@ -1599,96 +1646,112 @@ _PySwigObject_type(void) {
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
- (coercion)0, /*nb_coerce*/
- (unaryfunc)PySwigObject_long, /*nb_int*/
- (unaryfunc)PySwigObject_long, /*nb_long*/
+#if PY_VERSION_HEX < 0x03000000
+ 0, /*nb_coerce*/
+#endif
+ (unaryfunc)SwigPyObject_long, /*nb_int*/
+#if PY_VERSION_HEX < 0x03000000
+ (unaryfunc)SwigPyObject_long, /*nb_long*/
+#else
+ 0, /*nb_reserved*/
+#endif
(unaryfunc)0, /*nb_float*/
- (unaryfunc)PySwigObject_oct, /*nb_oct*/
- (unaryfunc)PySwigObject_hex, /*nb_hex*/
-#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
+#if PY_VERSION_HEX < 0x03000000
+ (unaryfunc)SwigPyObject_oct, /*nb_oct*/
+ (unaryfunc)SwigPyObject_hex, /*nb_hex*/
+#endif
+#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
+#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
+#else
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
-#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
- 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
-#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
- 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
#endif
};
- static PyTypeObject pyswigobject_type;
+ static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
- const PyTypeObject tmp
- = {
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
- (char *)"PySwigObject", /* tp_name */
- sizeof(PySwigObject), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor)PySwigObject_dealloc, /* tp_dealloc */
- (printfunc)PySwigObject_print, /* tp_print */
-#if PY_VERSION_HEX < 0x02020000
- (getattrfunc)PySwigObject_getattr, /* tp_getattr */
+ const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+ PyVarObject_HEAD_INIT(NULL, 0)
+#else
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+#endif
+ "SwigPyObject", /* tp_name */
+ sizeof(SwigPyObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)SwigPyObject_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc)0, /* tp_getattr */
+ (setattrfunc)0, /* tp_setattr */
+#if PY_VERSION_HEX >= 0x03000000
+ 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
- (getattrfunc)0, /* tp_getattr */
-#endif
- (setattrfunc)0, /* tp_setattr */
- (cmpfunc)PySwigObject_compare, /* tp_compare */
- (reprfunc)PySwigObject_repr, /* tp_repr */
- &PySwigObject_as_number, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- (reprfunc)PySwigObject_str, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
- swigobject_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
- 0, /* tp_iter */
- 0, /* tp_iternext */
- swigobject_methods, /* tp_methods */
- 0, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- 0, /* tp_new */
- 0, /* tp_free */
- 0, /* tp_is_gc */
- 0, /* tp_bases */
- 0, /* tp_mro */
- 0, /* tp_cache */
- 0, /* tp_subclasses */
- 0, /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
- 0, /* tp_del */
+ (cmpfunc)SwigPyObject_compare, /* tp_compare */
+#endif
+ (reprfunc)SwigPyObject_repr, /* tp_repr */
+ &SwigPyObject_as_number, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ (hashfunc)0, /* tp_hash */
+ (ternaryfunc)0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ swigobject_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ swigobject_methods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /* tp_new */
+ 0, /* tp_free */
+ 0, /* tp_is_gc */
+ 0, /* tp_bases */
+ 0, /* tp_mro */
+ 0, /* tp_cache */
+ 0, /* tp_subclasses */
+ 0, /* tp_weaklist */
+ 0, /* tp_del */
+ 0, /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 0, /* tp_allocs */
+ 0, /* tp_frees */
+ 0, /* tp_maxalloc */
+ 0, /* tp_prev */
+ 0 /* tp_next */
#endif
- };
- pyswigobject_type = tmp;
- pyswigobject_type.ob_type = &PyType_Type;
+ };
+ swigpyobject_type = tmp;
type_init = 1;
+ if (PyType_Ready(&swigpyobject_type) < 0)
+ return NULL;
}
- return &pyswigobject_type;
+ return &swigpyobject_type;
}
SWIGRUNTIME PyObject *
-PySwigObject_New(void *ptr, swig_type_info *ty, int own)
+SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
- PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
+ SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
@@ -1707,151 +1770,149 @@ typedef struct {
void *pack;
swig_type_info *ty;
size_t size;
-} PySwigPacked;
+} SwigPyPacked;
-SWIGRUNTIME int
-PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
-{
- char result[SWIG_BUFFER_SIZE];
- fputs("<Swig Packed ", fp);
- if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
- fputs("at ", fp);
- fputs(result, fp);
- }
- fputs(v->ty->name,fp);
- fputs(">", fp);
- return 0;
-}
-
SWIGRUNTIME PyObject *
-PySwigPacked_repr(PySwigPacked *v)
+SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
- return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
+ return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
- return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
+ return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
-PySwigPacked_str(PySwigPacked *v)
+SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
- return PyString_FromFormat("%s%s", result, v->ty->name);
+ return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
} else {
- return PyString_FromString(v->ty->name);
+ return SWIG_Python_str_FromChar(v->ty->name);
}
}
SWIGRUNTIME int
-PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
+SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
- return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
+ return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
-SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
+SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
-PySwigPacked_type(void) {
- static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
+SwigPyPacked_type(void) {
+ static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
-PySwigPacked_Check(PyObject *op) {
- return ((op)->ob_type == _PySwigPacked_type())
- || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
+SwigPyPacked_Check(PyObject *op) {
+ return ((op)->ob_type == SwigPyPacked_TypeOnce())
+ || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}
SWIGRUNTIME void
-PySwigPacked_dealloc(PyObject *v)
+SwigPyPacked_dealloc(PyObject *v)
{
- if (PySwigPacked_Check(v)) {
- PySwigPacked *sobj = (PySwigPacked *) v;
+ if (SwigPyPacked_Check(v)) {
+ SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_DEL(v);
}
SWIGRUNTIME PyTypeObject*
-_PySwigPacked_type(void) {
+SwigPyPacked_TypeOnce(void) {
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
- static PyTypeObject pyswigpacked_type;
- static int type_init = 0;
+ static PyTypeObject swigpypacked_type;
+ static int type_init = 0;
if (!type_init) {
- const PyTypeObject tmp
- = {
- PyObject_HEAD_INIT(NULL)
- 0, /* ob_size */
- (char *)"PySwigPacked", /* tp_name */
- sizeof(PySwigPacked), /* tp_basicsize */
- 0, /* tp_itemsize */
- (destructor)PySwigPacked_dealloc, /* tp_dealloc */
- (printfunc)PySwigPacked_print, /* tp_print */
- (getattrfunc)0, /* tp_getattr */
- (setattrfunc)0, /* tp_setattr */
- (cmpfunc)PySwigPacked_compare, /* tp_compare */
- (reprfunc)PySwigPacked_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)0, /* tp_hash */
- (ternaryfunc)0, /* tp_call */
- (reprfunc)PySwigPacked_str, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT, /* tp_flags */
- swigpacked_doc, /* tp_doc */
- 0, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
- 0, /* tp_iter */
- 0, /* tp_iternext */
- 0, /* tp_methods */
- 0, /* tp_members */
- 0, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- 0, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- 0, /* tp_new */
- 0, /* tp_free */
- 0, /* tp_is_gc */
- 0, /* tp_bases */
- 0, /* tp_mro */
- 0, /* tp_cache */
- 0, /* tp_subclasses */
- 0, /* tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
- 0, /* tp_del */
+ const PyTypeObject tmp = {
+#if PY_VERSION_HEX>=0x03000000
+ PyVarObject_HEAD_INIT(NULL, 0)
+#else
+ PyObject_HEAD_INIT(NULL)
+ 0, /* ob_size */
+#endif
+ "SwigPyPacked", /* tp_name */
+ sizeof(SwigPyPacked), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc)0, /* tp_getattr */
+ (setattrfunc)0, /* tp_setattr */
+#if PY_VERSION_HEX>=0x03000000
+ 0, /* tp_reserved in 3.0.1 */
+#else
+ (cmpfunc)SwigPyPacked_compare, /* tp_compare */
+#endif
+ (reprfunc)SwigPyPacked_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ (hashfunc)0, /* tp_hash */
+ (ternaryfunc)0, /* tp_call */
+ (reprfunc)SwigPyPacked_str, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ swigpacked_doc, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ 0, /* tp_new */
+ 0, /* tp_free */
+ 0, /* tp_is_gc */
+ 0, /* tp_bases */
+ 0, /* tp_mro */
+ 0, /* tp_cache */
+ 0, /* tp_subclasses */
+ 0, /* tp_weaklist */
+ 0, /* tp_del */
+ 0, /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 0, /* tp_allocs */
+ 0, /* tp_frees */
+ 0, /* tp_maxalloc */
+ 0, /* tp_prev */
+ 0 /* tp_next */
#endif
- };
- pyswigpacked_type = tmp;
- pyswigpacked_type.ob_type = &PyType_Type;
+ };
+ swigpypacked_type = tmp;
type_init = 1;
+ if (PyType_Ready(&swigpypacked_type) < 0)
+ return NULL;
}
- return &pyswigpacked_type;
+ return &swigpypacked_type;
}
SWIGRUNTIME PyObject *
-PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
+SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
- PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
+ SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
@@ -1868,10 +1929,10 @@ PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
}
SWIGRUNTIME swig_type_info *
-PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
+SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
- if (PySwigPacked_Check(obj)) {
- PySwigPacked *sobj = (PySwigPacked *)obj;
+ if (SwigPyPacked_Check(obj)) {
+ SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
@@ -1884,68 +1945,85 @@ PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
-SWIGRUNTIMEINLINE PyObject *
-_SWIG_This(void)
-{
- return PyString_FromString("this");
-}
+static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
- static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
- return swig_this;
+ if (Swig_This_global == NULL)
+ Swig_This_global = SWIG_Python_str_FromChar("this");
+ return Swig_This_global;
}
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
-SWIGRUNTIME PySwigObject *
+/* TODO: I don't know how to implement the fast getset in Python 3 right now */
+#if PY_VERSION_HEX>=0x03000000
+#define SWIG_PYTHON_SLOW_GETSET_THIS
+#endif
+
+SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
- if (PySwigObject_Check(pyobj)) {
- return (PySwigObject *) pyobj;
+ PyObject *obj;
+
+ if (SwigPyObject_Check(pyobj))
+ return (SwigPyObject *) pyobj;
+
+#ifdef SWIGPYTHON_BUILTIN
+ (void)obj;
+# ifdef PyWeakref_CheckProxy
+ if (PyWeakref_CheckProxy(pyobj)) {
+ pyobj = PyWeakref_GET_OBJECT(pyobj);
+ if (pyobj && SwigPyObject_Check(pyobj))
+ return (SwigPyObject*) pyobj;
+ }
+# endif
+ return NULL;
+#else
+
+ obj = 0;
+
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+ if (PyInstance_Check(pyobj)) {
+ obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
- PyObject *obj = 0;
-#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
- if (PyInstance_Check(pyobj)) {
- obj = _PyInstance_Lookup(pyobj, SWIG_This());
+ PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
+ if (dictptr != NULL) {
+ PyObject *dict = *dictptr;
+ obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
- PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
- if (dictptr != NULL) {
- PyObject *dict = *dictptr;
- obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
- } else {
#ifdef PyWeakref_CheckProxy
- if (PyWeakref_CheckProxy(pyobj)) {
- PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
- return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
- }
+ if (PyWeakref_CheckProxy(pyobj)) {
+ PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
+ return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
+ }
#endif
- obj = PyObject_GetAttr(pyobj,SWIG_This());
- if (obj) {
- Py_DECREF(obj);
- } else {
- if (PyErr_Occurred()) PyErr_Clear();
- return 0;
- }
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
+ if (obj) {
+ Py_DECREF(obj);
+ } else {
+ if (PyErr_Occurred()) PyErr_Clear();
+ return 0;
}
}
+ }
#else
- obj = PyObject_GetAttr(pyobj,SWIG_This());
- if (obj) {
- Py_DECREF(obj);
- } else {
- if (PyErr_Occurred()) PyErr_Clear();
- return 0;
- }
+ obj = PyObject_GetAttr(pyobj,SWIG_This());
+ if (obj) {
+ Py_DECREF(obj);
+ } else {
+ if (PyErr_Occurred()) PyErr_Clear();
+ return 0;
+ }
#endif
- if (obj && !PySwigObject_Check(obj)) {
- /* a PyObject is called 'this', try to get the 'real this'
- PySwigObject from it */
- return SWIG_Python_GetSwigThis(obj);
- }
- return (PySwigObject *)obj;
+ if (obj && !SwigPyObject_Check(obj)) {
+ /* a PyObject is called 'this', try to get the 'real this'
+ SwigPyObject from it */
+ return SWIG_Python_GetSwigThis(obj);
}
+ return (SwigPyObject *)obj;
+#endif
}
/* Acquire a pointer value */
@@ -1953,7 +2031,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj)
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+ SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
@@ -1967,91 +2045,105 @@ SWIG_Python_AcquirePtr(PyObject *obj, int own) {
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
- if (!obj) return SWIG_ERROR;
- if (obj == Py_None) {
- if (ptr) *ptr = 0;
- return SWIG_OK;
- } else {
- PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
- if (own)
- *own = 0;
- while (sobj) {
- void *vptr = sobj->ptr;
- if (ty) {
- swig_type_info *to = sobj->ty;
- if (to == ty) {
- /* no type cast needed */
- if (ptr) *ptr = vptr;
- break;
- } else {
- swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
- if (!tc) {
- sobj = (PySwigObject *)sobj->next;
- } else {
- if (ptr) {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
- if (newmemory == SWIG_CAST_NEW_MEMORY) {
- assert(own);
- if (own)
- *own = *own | SWIG_CAST_NEW_MEMORY;
- }
- }
- break;
- }
- }
+ int res;
+ SwigPyObject *sobj;
+ int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
+
+ if (!obj)
+ return SWIG_ERROR;
+ if (obj == Py_None && !implicit_conv) {
+ if (ptr)
+ *ptr = 0;
+ return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
+ }
+
+ res = SWIG_ERROR;
+
+ sobj = SWIG_Python_GetSwigThis(obj);
+ if (own)
+ *own = 0;
+ while (sobj) {
+ void *vptr = sobj->ptr;
+ if (ty) {
+ swig_type_info *to = sobj->ty;
+ if (to == ty) {
+ /* no type cast needed */
+ if (ptr) *ptr = vptr;
+ break;
} else {
- if (ptr) *ptr = vptr;
- break;
+ swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
+ if (!tc) {
+ sobj = (SwigPyObject *)sobj->next;
+ } else {
+ if (ptr) {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
+ assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+ if (own)
+ *own = *own | SWIG_CAST_NEW_MEMORY;
+ }
+ }
+ break;
+ }
}
+ } else {
+ if (ptr) *ptr = vptr;
+ break;
}
- if (sobj) {
- if (own)
- *own = *own | sobj->own;
- if (flags & SWIG_POINTER_DISOWN) {
- sobj->own = 0;
+ }
+ if (sobj) {
+ if (own)
+ *own = *own | sobj->own;
+ if (flags & SWIG_POINTER_DISOWN) {
+ sobj->own = 0;
+ }
+ res = SWIG_OK;
+ } else {
+ if (implicit_conv) {
+ SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
+ if (data && !data->implicitconv) {
+ PyObject *klass = data->klass;
+ if (klass) {
+ PyObject *impconv;
+ data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
+ impconv = SWIG_Python_CallFunctor(klass, obj);
+ data->implicitconv = 0;
+ if (PyErr_Occurred()) {
+ PyErr_Clear();
+ impconv = 0;
+ }
+ if (impconv) {
+ SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
+ if (iobj) {
+ void *vptr;
+ res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
+ if (SWIG_IsOK(res)) {
+ if (ptr) {
+ *ptr = vptr;
+ /* transfer the ownership to 'ptr' */
+ iobj->own = 0;
+ res = SWIG_AddCast(res);
+ res = SWIG_AddNewMask(res);
+ } else {
+ res = SWIG_AddCast(res);
+ }
+ }
+ }
+ Py_DECREF(impconv);
+ }
+ }
}
- return SWIG_OK;
- } else {
- int res = SWIG_ERROR;
- if (flags & SWIG_POINTER_IMPLICIT_CONV) {
- PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
- if (data && !data->implicitconv) {
- PyObject *klass = data->klass;
- if (klass) {
- PyObject *impconv;
- data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
- impconv = SWIG_Python_CallFunctor(klass, obj);
- data->implicitconv = 0;
- if (PyErr_Occurred()) {
- PyErr_Clear();
- impconv = 0;
- }
- if (impconv) {
- PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
- if (iobj) {
- void *vptr;
- res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
- if (SWIG_IsOK(res)) {
- if (ptr) {
- *ptr = vptr;
- /* transfer the ownership to 'ptr' */
- iobj->own = 0;
- res = SWIG_AddCast(res);
- res = SWIG_AddNewMask(res);
- } else {
- res = SWIG_AddCast(res);
- }
- }
- }
- Py_DECREF(impconv);
- }
- }
- }
+ if (!SWIG_IsOK(res) && obj == Py_None) {
+ if (ptr)
+ *ptr = 0;
+ if (PyErr_Occurred())
+ PyErr_Clear();
+ res = SWIG_OK;
}
- return res;
}
}
+ return res;
}
/* Convert a function ptr value */
@@ -2062,35 +2154,32 @@ SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
-
+ swig_cast_info *tc;
+
/* here we get the method pointer for callbacks */
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
- if (desc) {
+ if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
- if (!desc) return SWIG_ERROR;
- }
- if (ty) {
- swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
- if (tc) {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
- } else {
- return SWIG_ERROR;
- }
+ if (!desc)
+ return SWIG_ERROR;
+ tc = SWIG_TypeCheck(desc,ty);
+ if (tc) {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+ assert(!newmemory); /* newmemory handling not yet implemented */
} else {
- *ptr = vptr;
+ return SWIG_ERROR;
}
return SWIG_OK;
}
}
-/* Convert a packed value value */
+/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
- swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
+ swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
@@ -2107,14 +2196,13 @@ SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *t
* ----------------------------------------------------------------------------- */
/*
- Create a new instance object, whitout calling __init__, and set the
+ Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
-SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
+SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
-#if (PY_VERSION_HEX >= 0x02020000)
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
@@ -2136,49 +2224,37 @@ SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
#endif
}
} else {
+#if PY_VERSION_HEX >= 0x03000000
+ PyObject *empty_args = PyTuple_New(0);
+ if (empty_args) {
+ PyObject *empty_kwargs = PyDict_New();
+ if (empty_kwargs) {
+ inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
+ Py_DECREF(empty_kwargs);
+ if (inst) {
+ PyObject_SetAttr(inst, SWIG_This(), swig_this);
+ Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
+ }
+ }
+ Py_DECREF(empty_args);
+ }
+#else
PyObject *dict = PyDict_New();
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- inst = PyInstance_NewRaw(data->newargs, dict);
- Py_DECREF(dict);
+ if (dict) {
+ PyDict_SetItem(dict, SWIG_This(), swig_this);
+ inst = PyInstance_NewRaw(data->newargs, dict);
+ Py_DECREF(dict);
+ }
+#endif
}
return inst;
-#else
-#if (PY_VERSION_HEX >= 0x02010000)
- PyObject *inst;
- PyObject *dict = PyDict_New();
- PyDict_SetItem(dict, SWIG_This(), swig_this);
- inst = PyInstance_NewRaw(data->newargs, dict);
- Py_DECREF(dict);
- return (PyObject *) inst;
-#else
- PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
- if (inst == NULL) {
- return NULL;
- }
- inst->in_class = (PyClassObject *)data->newargs;
- Py_INCREF(inst->in_class);
- inst->in_dict = PyDict_New();
- if (inst->in_dict == NULL) {
- Py_DECREF(inst);
- return NULL;
- }
-#ifdef Py_TPFLAGS_HAVE_WEAKREFS
- inst->in_weakreflist = NULL;
-#endif
-#ifdef Py_TPFLAGS_GC
- PyObject_GC_Init(inst);
-#endif
- PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
- return (PyObject *) inst;
-#endif
-#endif
}
SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
PyObject *dict;
-#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
+#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
PyObject **dictptr = _PyObject_GetDictPtr(inst);
if (dictptr != NULL) {
dict = *dictptr;
@@ -2190,7 +2266,7 @@ SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
return;
}
#endif
- dict = PyObject_GetAttrString(inst, (char*)"__dict__");
+ dict = PyObject_GetAttrString(inst, "__dict__");
PyDict_SetItem(dict, SWIG_This(), swig_this);
Py_DECREF(dict);
}
@@ -2199,12 +2275,12 @@ SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
- if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
+ if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
- PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
+ SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
- PySwigObject_append((PyObject*) sthis, obj[1]);
+ SwigPyObject_append((PyObject*) sthis, obj[1]);
} else {
SWIG_Python_SetSwigThis(obj[0], obj[1]);
}
@@ -2215,29 +2291,62 @@ SWIG_Python_InitShadowInstance(PyObject *args) {
/* Create a new pointer object */
SWIGRUNTIME PyObject *
-SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
- if (!ptr) {
+SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
+ SwigPyClientData *clientdata;
+ PyObject * robj;
+ int own;
+
+ if (!ptr)
return SWIG_Py_Void();
- } else {
- int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
- PyObject *robj = PySwigObject_New(ptr, type, own);
- PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
- if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
- PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
- if (inst) {
- Py_DECREF(robj);
- robj = inst;
+
+ clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
+ own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+ if (clientdata && clientdata->pytype) {
+ SwigPyObject *newobj;
+ if (flags & SWIG_BUILTIN_TP_INIT) {
+ newobj = (SwigPyObject*) self;
+ if (newobj->ptr) {
+ PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
+ while (newobj->next)
+ newobj = (SwigPyObject *) newobj->next;
+ newobj->next = next_self;
+ newobj = (SwigPyObject *)next_self;
+#ifdef SWIGPYTHON_BUILTIN
+ newobj->dict = 0;
+#endif
}
+ } else {
+ newobj = PyObject_New(SwigPyObject, clientdata->pytype);
+#ifdef SWIGPYTHON_BUILTIN
+ newobj->dict = 0;
+#endif
}
- return robj;
+ if (newobj) {
+ newobj->ptr = ptr;
+ newobj->ty = type;
+ newobj->own = own;
+ newobj->next = 0;
+ return (PyObject*) newobj;
+ }
+ return SWIG_Py_Void();
}
+
+ assert(!(flags & SWIG_BUILTIN_TP_INIT));
+
+ robj = SwigPyObject_New(ptr, type, own);
+ if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
+ PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
+ Py_DECREF(robj);
+ robj = inst;
+ }
+ return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
- return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
+ return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
@@ -2249,15 +2358,14 @@ void *SWIG_ReturnGlobalTypeList(void *);
#endif
SWIGRUNTIME swig_module_info *
-SWIG_Python_GetModule(void) {
+SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
- type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
- (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
+ type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
@@ -2267,63 +2375,35 @@ SWIG_Python_GetModule(void) {
return (swig_module_info *) type_pointer;
}
-#if PY_MAJOR_VERSION < 2
-/* PyModule_AddObject function was introduced in Python 2.0. The following function
- is copied out of Python/modsupport.c in python version 2.3.4 */
-SWIGINTERN int
-PyModule_AddObject(PyObject *m, char *name, PyObject *o)
-{
- PyObject *dict;
- if (!PyModule_Check(m)) {
- PyErr_SetString(PyExc_TypeError,
- "PyModule_AddObject() needs module as first arg");
- return SWIG_ERROR;
- }
- if (!o) {
- PyErr_SetString(PyExc_TypeError,
- "PyModule_AddObject() needs non-NULL value");
- return SWIG_ERROR;
- }
-
- dict = PyModule_GetDict(m);
- if (dict == NULL) {
- /* Internal error -- modules must have a dict! */
- PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
- PyModule_GetName(m));
- return SWIG_ERROR;
- }
- if (PyDict_SetItemString(dict, name, o))
- return SWIG_ERROR;
- Py_DECREF(o);
- return SWIG_OK;
-}
-#endif
-
SWIGRUNTIME void
-SWIG_Python_DestroyModule(void *vptr)
+SWIG_Python_DestroyModule(PyObject *obj)
{
- swig_module_info *swig_module = (swig_module_info *) vptr;
+ swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
for (i =0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
- PySwigClientData *data = (PySwigClientData *) ty->clientdata;
- if (data) PySwigClientData_Del(data);
+ SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
+ if (data) SwigPyClientData_Del(data);
}
}
Py_DECREF(SWIG_This());
+ Swig_This_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
- static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
-
- PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
- swig_empty_runtime_method_table);
- PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
+#if PY_VERSION_HEX >= 0x03000000
+ /* Add a dummy module object into sys.modules */
+ PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
+#else
+ static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
+ PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
+#endif
+ PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && module) {
- PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
+ PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
} else {
Py_XDECREF(pointer);
}
@@ -2340,16 +2420,16 @@ SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
PyObject *cache = SWIG_Python_TypeCache();
- PyObject *key = PyString_FromString(type);
+ PyObject *key = SWIG_Python_str_FromChar(type);
PyObject *obj = PyDict_GetItem(cache, key);
swig_type_info *descriptor;
if (obj) {
- descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
+ descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
- swig_module_info *swig_module = SWIG_Python_GetModule();
+ swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
- obj = PyCObject_FromVoidPtr(descriptor, NULL);
+ obj = PyCapsule_New((void*) descriptor, NULL, NULL);
PyDict_SetItem(cache, key, obj);
Py_DECREF(obj);
}
@@ -2367,7 +2447,7 @@ SWIG_Python_TypeQuery(const char *type)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
-{
+{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
@@ -2375,13 +2455,16 @@ SWIG_Python_AddErrMesg(const char* mesg, int infront)
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
+ const char *tmp = SWIG_Python_str_AsChar(old_str);
+ const char *errmesg = tmp ? tmp : "Invalid error message";
Py_XINCREF(type);
PyErr_Clear();
if (infront) {
- PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
+ PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
- PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
+ PyErr_Format(type, "%s %s", errmesg, mesg);
}
+ SWIG_Python_str_DelForPy3(tmp);
Py_DECREF(old_str);
}
return 1;
@@ -2404,11 +2487,11 @@ SWIG_Python_ArgFail(int argnum)
}
SWIGRUNTIMEINLINE const char *
-PySwigObject_GetDesc(PyObject *self)
+SwigPyObject_GetDesc(PyObject *self)
{
- PySwigObject *v = (PySwigObject *)self;
+ SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
- return ty ? ty->str : (char*)"";
+ return ty ? ty->str : "";
}
SWIGRUNTIME void
@@ -2416,10 +2499,10 @@ SWIG_Python_TypeError(const char *type, PyObject *obj)
{
if (type) {
#if defined(SWIG_COBJECT_TYPES)
- if (obj && PySwigObject_Check(obj)) {
- const char *otype = (const char *) PySwigObject_GetDesc(obj);
+ if (obj && SwigPyObject_Check(obj)) {
+ const char *otype = (const char *) SwigPyObject_GetDesc(obj);
if (otype) {
- PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
+ PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
type, otype);
return;
}
@@ -2429,10 +2512,11 @@ SWIG_Python_TypeError(const char *type, PyObject *obj)
const char *otype = (obj ? obj->ob_type->tp_name : 0);
if (otype) {
PyObject *str = PyObject_Str(obj);
- const char *cstr = str ? PyString_AsString(str) : 0;
+ const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
if (cstr) {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
type, otype, cstr);
+ SWIG_Python_str_DelForPy3(cstr);
} else {
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
type, otype);
@@ -2450,23 +2534,77 @@ SWIG_Python_TypeError(const char *type, PyObject *obj)
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
-SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
+SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
- if (flags & SWIG_POINTER_EXCEPTION) {
+#if SWIG_POINTER_EXCEPTION
+ if (flags) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
}
+#endif
}
return result;
}
+#ifdef SWIGPYTHON_BUILTIN
+SWIGRUNTIME int
+SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
+ PyTypeObject *tp = obj->ob_type;
+ PyObject *descr;
+ PyObject *encoded_name;
+ descrsetfunc f;
+ int res = -1;
+
+# ifdef Py_USING_UNICODE
+ if (PyString_Check(name)) {
+ name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
+ if (!name)
+ return -1;
+ } else if (!PyUnicode_Check(name))
+# else
+ if (!PyString_Check(name))
+# endif
+ {
+ PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
+ return -1;
+ } else {
+ Py_INCREF(name);
+ }
-#ifdef __cplusplus
-#if 0
-{ /* cc-mode */
+ if (!tp->tp_dict) {
+ if (PyType_Ready(tp) < 0)
+ goto done;
+ }
+
+ descr = _PyType_Lookup(tp, name);
+ f = NULL;
+ if (descr != NULL)
+ f = descr->ob_type->tp_descr_set;
+ if (!f) {
+ if (PyString_Check(name)) {
+ encoded_name = name;
+ Py_INCREF(name);
+ } else {
+ encoded_name = PyUnicode_AsUTF8String(name);
+ if (!encoded_name)
+ return -1;
+ }
+ PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
+ Py_DECREF(encoded_name);
+ } else {
+ res = f(descr, obj, value);
+ }
+
+ done:
+ Py_DECREF(name);
+ return res;
+}
#endif
+
+
+#ifdef __cplusplus
}
#endif
@@ -2478,34 +2616,66 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags)
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Method creation and docstring support functions */
+
+SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
+SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
+SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
+
+#ifdef __cplusplus
+}
+#endif
+
+
/* -------- TYPES TABLE (BEGIN) -------- */
-#define SWIGTYPE_p_char swig_types[0]
-#define SWIGTYPE_p_double swig_types[1]
-#define SWIGTYPE_p_float swig_types[2]
-#define SWIGTYPE_p_int swig_types[3]
-#define SWIGTYPE_p_off_t swig_types[4]
-static swig_type_info *swig_types[6];
-static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
+#define SWIGTYPE_p_CdiGribIterator swig_types[0]
+#define SWIGTYPE_p_CdiIterator swig_types[1]
+#define SWIGTYPE_p_CdiParam swig_types[2]
+#define SWIGTYPE_p_FILE swig_types[3]
+#define SWIGTYPE_p_a_10__int swig_types[4]
+#define SWIGTYPE_p_a_2__int swig_types[5]
+#define SWIGTYPE_p_char swig_types[6]
+#define SWIGTYPE_p_double swig_types[7]
+#define SWIGTYPE_p_float swig_types[8]
+#define SWIGTYPE_p_int swig_types[9]
+#define SWIGTYPE_p_int64_t swig_types[10]
+#define SWIGTYPE_p_long swig_types[11]
+#define SWIGTYPE_p_off_t swig_types[12]
+#define SWIGTYPE_p_p_char swig_types[13]
+#define SWIGTYPE_p_p_p_char swig_types[14]
+#define SWIGTYPE_p_size_t swig_types[15]
+#define SWIGTYPE_p_subtype_query_t swig_types[16]
+#define SWIGTYPE_p_unsigned_char swig_types[17]
+static swig_type_info *swig_types[19];
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
/* -------- TYPES TABLE (END) -------- */
-#if (PY_VERSION_HEX <= 0x02000000)
-# if !defined(SWIG_PYTHON_CLASSIC)
-# error "This python version requires swig to be run with the '-classic' option"
-# endif
+#ifdef SWIG_TypeQuery
+# undef SWIG_TypeQuery
#endif
+#define SWIG_TypeQuery SWIG_Python_TypeQuery
/*-----------------------------------------------
@(target):= _CdiLib.so
------------------------------------------------*/
-#define SWIG_init init_CdiLib
+#if PY_VERSION_HEX >= 0x03000000
+# define SWIG_init PyInit__CdiLib
+
+#else
+# define SWIG_init init_CdiLib
+#endif
#define SWIG_name "_CdiLib"
-#define SWIGVERSION 0x010336
+#define SWIGVERSION 0x040000
#define SWIG_VERSION SWIGVERSION
@@ -2516,13 +2686,10 @@ static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
#include "cdi.h"
- #define SWIG_From_long PyInt_FromLong
-
-
-SWIGINTERNINLINE PyObject *
-SWIG_From_int (int value)
-{
- return SWIG_From_long (value);
+SWIGINTERNINLINE PyObject*
+ SWIG_From_int (int value)
+{
+ return PyInt_FromLong((long) value);
}
@@ -2543,9 +2710,11 @@ SWIG_AsVal_double (PyObject *obj, double *val)
if (PyFloat_Check(obj)) {
if (val) *val = PyFloat_AsDouble(obj);
return SWIG_OK;
+#if PY_VERSION_HEX < 0x03000000
} else if (PyInt_Check(obj)) {
- if (val) *val = PyInt_AsLong(obj);
+ if (val) *val = (double) PyInt_AsLong(obj);
return SWIG_OK;
+#endif
} else if (PyLong_Check(obj)) {
double v = PyLong_AsDouble(obj);
if (!PyErr_Occurred()) {
@@ -2619,16 +2788,20 @@ SWIG_CanCastAsInteger(double *d, double min, double max) {
SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
+#if PY_VERSION_HEX < 0x03000000
if (PyInt_Check(obj)) {
if (val) *val = PyInt_AsLong(obj);
return SWIG_OK;
- } else if (PyLong_Check(obj)) {
+ } else
+#endif
+ if (PyLong_Check(obj)) {
long v = PyLong_AsLong(obj);
if (!PyErr_Occurred()) {
if (val) *val = v;
return SWIG_OK;
} else {
PyErr_Clear();
+ return SWIG_OverflowError;
}
}
#ifdef SWIG_PYTHON_CAST_MODE
@@ -2691,9 +2864,17 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
if (size > INT_MAX) {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
return pchar_descriptor ?
- SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
+ SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
} else {
- return PyString_FromStringAndSize(carray, (int)(size));
+#if PY_VERSION_HEX >= 0x03000000
+#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+ return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
+#else
+ return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
+#endif
+#else
+ return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
+#endif
}
} else {
return SWIG_Py_Void();
@@ -2714,44 +2895,99 @@ SWIG_FromCharPtr(const char *cptr)
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
- if (PyString_Check(obj)) {
+#if PY_VERSION_HEX>=0x03000000
+#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+ if (PyBytes_Check(obj))
+#else
+ if (PyUnicode_Check(obj))
+#endif
+#else
+ if (PyString_Check(obj))
+#endif
+ {
char *cstr; Py_ssize_t len;
- PyString_AsStringAndSize(obj, &cstr, &len);
- if (cptr) {
- if (alloc) {
- /*
- In python the user should not be able to modify the inner
- string representation. To warranty that, if you define
- SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
- buffer is always returned.
-
- The default behavior is just to return the pointer value,
- so, be careful.
- */
-#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
- if (*alloc != SWIG_OLDOBJ)
+ int ret = SWIG_OK;
+#if PY_VERSION_HEX>=0x03000000
+#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+ if (!alloc && cptr) {
+ /* We can't allow converting without allocation, since the internal
+ representation of string in Python 3 is UCS-2/UCS-4 but we require
+ a UTF-8 representation.
+ TODO(bhy) More detailed explanation */
+ return SWIG_RuntimeError;
+ }
+ obj = PyUnicode_AsUTF8String(obj);
+ if (!obj)
+ return SWIG_TypeError;
+ if (alloc)
+ *alloc = SWIG_NEWOBJ;
+#endif
+ PyBytes_AsStringAndSize(obj, &cstr, &len);
#else
- if (*alloc == SWIG_NEWOBJ)
+ PyString_AsStringAndSize(obj, &cstr, &len);
#endif
- {
- *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
- *alloc = SWIG_NEWOBJ;
- }
- else {
+ if (cptr) {
+ if (alloc) {
+ if (*alloc == SWIG_NEWOBJ) {
+ *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
+ *alloc = SWIG_NEWOBJ;
+ } else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
- *cptr = PyString_AsString(obj);
+#if PY_VERSION_HEX>=0x03000000
+#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+ *cptr = PyBytes_AsString(obj);
+#else
+ assert(0); /* Should never reach here with Unicode strings in Python 3 */
+#endif
+#else
+ *cptr = SWIG_Python_str_AsChar(obj);
+ if (!*cptr)
+ ret = SWIG_TypeError;
+#endif
}
}
if (psize) *psize = len + 1;
- return SWIG_OK;
+#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+ Py_XDECREF(obj);
+#endif
+ return ret;
} else {
- swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
- if (pchar_descriptor) {
- void* vptr = 0;
- if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+#if defined(SWIG_PYTHON_2_UNICODE)
+#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
+#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
+#endif
+#if PY_VERSION_HEX<0x03000000
+ if (PyUnicode_Check(obj)) {
+ char *cstr; Py_ssize_t len;
+ if (!alloc && cptr) {
+ return SWIG_RuntimeError;
+ }
+ obj = PyUnicode_AsUTF8String(obj);
+ if (!obj)
+ return SWIG_TypeError;
+ if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
+ if (cptr) {
+ if (alloc) *alloc = SWIG_NEWOBJ;
+ *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
+ }
+ if (psize) *psize = len + 1;
+
+ Py_XDECREF(obj);
+ return SWIG_OK;
+ } else {
+ Py_XDECREF(obj);
+ }
+ }
+#endif
+#endif
+
+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+ if (pchar_descriptor) {
+ void* vptr = 0;
+ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
@@ -2765,242 +3001,451 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
+
+ #define SWIG_From_long PyInt_FromLong
+
+
+SWIGINTERNINLINE PyObject*
+SWIG_From_unsigned_SS_long (unsigned long value)
+{
+ return (value > LONG_MAX) ?
+ PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
+}
+
+
+#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
+# define SWIG_LONG_LONG_AVAILABLE
+#endif
+
+
+#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE PyObject*
+SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
+{
+ return (value > LONG_MAX) ?
+ PyLong_FromUnsignedLongLong(value) : PyInt_FromLong((long)(value));
+}
+#endif
+
+
+SWIGINTERNINLINE PyObject *
+SWIG_From_size_t (size_t value)
+{
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ if (sizeof(size_t) <= sizeof(unsigned long)) {
+#endif
+ return SWIG_From_unsigned_SS_long ((unsigned long)(value));
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ } else {
+ /* assume sizeof(size_t) <= sizeof(unsigned long long) */
+ return SWIG_From_unsigned_SS_long_SS_long ((unsigned long long)(value));
+ }
+#endif
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
+{
+#if PY_VERSION_HEX < 0x03000000
+ if (PyInt_Check(obj)) {
+ long v = PyInt_AsLong(obj);
+ if (v >= 0) {
+ if (val) *val = v;
+ return SWIG_OK;
+ } else {
+ return SWIG_OverflowError;
+ }
+ } else
+#endif
+ if (PyLong_Check(obj)) {
+ unsigned long v = PyLong_AsUnsignedLong(obj);
+ if (!PyErr_Occurred()) {
+ if (val) *val = v;
+ return SWIG_OK;
+ } else {
+ PyErr_Clear();
+ return SWIG_OverflowError;
+ }
+ }
+#ifdef SWIG_PYTHON_CAST_MODE
+ {
+ int dispatch = 0;
+ unsigned long v = PyLong_AsUnsignedLong(obj);
+ if (!PyErr_Occurred()) {
+ if (val) *val = v;
+ return SWIG_AddCast(SWIG_OK);
+ } else {
+ PyErr_Clear();
+ }
+ if (!dispatch) {
+ double d;
+ int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+ if (val) *val = (unsigned long)(d);
+ return res;
+ }
+ }
+ }
+#endif
+ return SWIG_TypeError;
+}
+
+
+#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
+{
+ int res = SWIG_TypeError;
+ if (PyLong_Check(obj)) {
+ unsigned long long v = PyLong_AsUnsignedLongLong(obj);
+ if (!PyErr_Occurred()) {
+ if (val) *val = v;
+ return SWIG_OK;
+ } else {
+ PyErr_Clear();
+ res = SWIG_OverflowError;
+ }
+ } else {
+ unsigned long v;
+ res = SWIG_AsVal_unsigned_SS_long (obj,&v);
+ if (SWIG_IsOK(res)) {
+ if (val) *val = v;
+ return res;
+ }
+ }
+#ifdef SWIG_PYTHON_CAST_MODE
+ {
+ const double mant_max = 1LL << DBL_MANT_DIG;
+ double d;
+ res = SWIG_AsVal_double (obj,&d);
+ if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
+ return SWIG_OverflowError;
+ if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
+ if (val) *val = (unsigned long long)(d);
+ return SWIG_AddCast(res);
+ }
+ res = SWIG_TypeError;
+ }
+#endif
+ return res;
+}
+#endif
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t (PyObject * obj, size_t *val)
+{
+ int res = SWIG_TypeError;
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ if (sizeof(size_t) <= sizeof(unsigned long)) {
+#endif
+ unsigned long v;
+ res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
+ unsigned long long v;
+ res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+ }
+#endif
+ return res;
+}
+
#ifdef __cplusplus
extern "C" {
#endif
-SWIGINTERN PyObject *_wrap_cdiStringError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtype_query_t_nAND_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- char *result = 0 ;
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:cdiStringError",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiStringError" "', argument " "1"" of type '" "int""'");
+ if (!SWIG_Python_UnpackTuple(args, "subtype_query_t_nAND_set", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subtype_query_t_nAND_set" "', argument " "1"" of type '" "subtype_query_t *""'");
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subtype_query_t_nAND_set" "', argument " "2"" of type '" "int""'");
}
- arg1 = (int)(val1);
- result = (char *)cdiStringError(arg1);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->nAND = arg2;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtype_query_t_nAND_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:cdiDebug",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDebug" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- cdiDebug(arg1);
- resultobj = SWIG_Py_Void();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subtype_query_t_nAND_get" "', argument " "1"" of type '" "subtype_query_t *""'");
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ result = (int) ((arg1)->nAND);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtype_query_t_key_value_pairs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *result = 0 ;
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ int (*arg2)[10] ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)":cdiLibraryVersion")) SWIG_fail;
- result = (char *)cdiLibraryVersion();
- resultobj = SWIG_FromCharPtr((const char *)result);
+ if (!SWIG_Python_UnpackTuple(args, "subtype_query_t_key_value_pairs_set", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subtype_query_t_key_value_pairs_set" "', argument " "1"" of type '" "subtype_query_t *""'");
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_a_10__int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subtype_query_t_key_value_pairs_set" "', argument " "2"" of type '" "int [2][10]""'");
+ }
+ arg2 = (int (*)[10])(argp2);
+ {
+ if (arg2) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) {
+ if (arg2[ii]) {
+ size_t jj = 0;
+ for (; jj < (size_t)10; ++jj) arg1->key_value_pairs[ii][jj] = arg2[ii][jj];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""key_value_pairs""' of type '""int [2][10]""'");
+ }
+ }
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""key_value_pairs""' of type '""int [2][10]""'");
+ }
+ }
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiPrintVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtype_query_t_key_value_pairs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int (*result)[10] = 0 ;
- if (!PyArg_ParseTuple(args,(char *)":cdiPrintVersion")) SWIG_fail;
- cdiPrintVersion();
- resultobj = SWIG_Py_Void();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subtype_query_t_key_value_pairs_get" "', argument " "1"" of type '" "subtype_query_t *""'");
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ result = (int (*)[10])(int (*)[10]) ((arg1)->key_value_pairs);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_10__int, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiDefMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_subtype_query_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- double arg1 ;
- double val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ subtype_query_t *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:cdiDefMissval",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_double(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefMissval" "', argument " "1"" of type '" "double""'");
- }
- arg1 = (double)(val1);
- cdiDefMissval(arg1);
- resultobj = SWIG_Py_Void();
+ if (!SWIG_Python_UnpackTuple(args, "new_subtype_query_t", 0, 0, 0)) SWIG_fail;
+ result = (subtype_query_t *)calloc(1, sizeof(subtype_query_t));
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_subtype_query_t, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiInqMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_subtype_query_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- double result;
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)":cdiInqMissval")) SWIG_fail;
- result = (double)cdiInqMissval();
- resultobj = SWIG_From_double((double)(result));
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subtype_query_t, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_subtype_query_t" "', argument " "1"" of type '" "subtype_query_t *""'");
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ free((char *) arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_cdiDefGlobal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *subtype_query_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_subtype_query_t, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *subtype_query_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_CdiParam_discipline_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *arg1 = (char *) 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:cdiDefGlobal",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!SWIG_Python_UnpackTuple(args, "CdiParam_discipline_set", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiDefGlobal" "', argument " "1"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_discipline_set" "', argument " "1"" of type '" "struct CdiParam *""'");
}
- arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefGlobal" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdiParam_discipline_set" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- cdiDefGlobal((char const *)arg1,arg2);
+ if (arg1) (arg1)->discipline = arg2;
resultobj = SWIG_Py_Void();
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamOpenRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CdiParam_discipline_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *arg1 = (char *) 0 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
- PyObject * obj0 = 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamOpenRead",&obj0)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenRead" "', argument " "1"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_discipline_get" "', argument " "1"" of type '" "struct CdiParam *""'");
}
- arg1 = (char *)(buf1);
- result = (int)streamOpenRead((char const *)arg1);
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->discipline);
resultobj = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamOpenWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CdiParam_category_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *arg1 = (char *) 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamOpenWrite",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!SWIG_Python_UnpackTuple(args, "CdiParam_category_set", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenWrite" "', argument " "1"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_category_set" "', argument " "1"" of type '" "struct CdiParam *""'");
}
- arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamOpenWrite" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdiParam_category_set" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)streamOpenWrite((char const *)arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (arg1) (arg1)->category = arg2;
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamOpenAppend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CdiParam_category_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *arg1 = (char *) 0 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
- PyObject * obj0 = 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamOpenAppend",&obj0)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenAppend" "', argument " "1"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_category_get" "', argument " "1"" of type '" "struct CdiParam *""'");
}
- arg1 = (char *)(buf1);
- result = (int)streamOpenAppend((char const *)arg1);
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->category);
resultobj = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamClose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CdiParam_number_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamClose",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamClose" "', argument " "1"" of type '" "int""'");
+ if (!SWIG_Python_UnpackTuple(args, "CdiParam_number_set", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_number_set" "', argument " "1"" of type '" "struct CdiParam *""'");
+ }
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CdiParam_number_set" "', argument " "2"" of type '" "int""'");
}
- arg1 = (int)(val1);
- streamClose(arg1);
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->number = arg2;
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3008,206 +3453,150 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamSync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_CdiParam_number_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamSync",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamSync" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- streamSync(arg1);
- resultobj = SWIG_Py_Void();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CdiParam_number_get" "', argument " "1"" of type '" "struct CdiParam *""'");
+ }
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->number);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefVlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_CdiParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ struct CdiParam *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamDefVlist",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefVlist" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefVlist" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- streamDefVlist(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ if (!SWIG_Python_UnpackTuple(args, "new_CdiParam", 0, 0, 0)) SWIG_fail;
+ result = (struct CdiParam *)calloc(1, sizeof(struct CdiParam));
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiParam, SWIG_POINTER_NEW | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamInqVlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_CdiParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqVlist",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqVlist" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- result = (int)streamInqVlist(arg1);
- resultobj = SWIG_From_int((int)(result));
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiParam, SWIG_POINTER_DISOWN | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CdiParam" "', argument " "1"" of type '" "struct CdiParam *""'");
+ }
+ arg1 = (struct CdiParam *)(argp1);
+ free((char *) arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamInqFiletype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *CdiParam_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *obj;
+ if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
+ SWIG_TypeNewClientData(SWIGTYPE_p_CdiParam, SWIG_NewClientData(obj));
+ return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *CdiParam_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ return SWIG_Python_InitShadowInstance(args);
+}
+
+SWIGINTERN PyObject *_wrap_cdiReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqFiletype",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqFiletype" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- result = (int)streamInqFiletype(arg1);
- resultobj = SWIG_From_int((int)(result));
+ if (!SWIG_Python_UnpackTuple(args, "cdiReset", 0, 0, 0)) SWIG_fail;
+ cdiReset();
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefByteorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiStringError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamDefByteorder",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefByteorder" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiStringError" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefByteorder" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- streamDefByteorder(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (char *)cdiStringError(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamInqByteorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqByteorder",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqByteorder" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDebug" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)streamInqByteorder(arg1);
- resultobj = SWIG_From_int((int)(result));
+ cdiDebug(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefZtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamDefZtype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefZtype" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefZtype" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- streamDefZtype(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ if (!SWIG_Python_UnpackTuple(args, "cdiLibraryVersion", 0, 0, 0)) SWIG_fail;
+ result = (char *)cdiLibraryVersion();
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefZlevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiPrintVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamDefZlevel",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefZlevel" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefZlevel" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- streamDefZlevel(arg1,arg2);
+ if (!SWIG_Python_UnpackTuple(args, "cdiPrintVersion", 0, 0, 0)) SWIG_fail;
+ cdiPrintVersion();
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3215,21 +3604,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamInqZtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiHaveFiletype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqZtype",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqZtype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiHaveFiletype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)streamInqZtype(arg1);
+ result = (int)cdiHaveFiletype(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -3237,83 +3627,92 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamInqZlevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDefMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
+ double arg1 ;
+ double val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqZlevel",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqZlevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefMissval" "', argument " "1"" of type '" "double""'");
}
- arg1 = (int)(val1);
- result = (int)streamInqZlevel(arg1);
- resultobj = SWIG_From_int((int)(result));
+ arg1 = (double)(val1);
+ cdiDefMissval(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiInqMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqMissval", 0, 0, 0)) SWIG_fail;
+ result = (double)cdiInqMissval();
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqGridMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqGridMissval", 0, 0, 0)) SWIG_fail;
+ result = (double)cdiInqGridMissval();
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDefGlobal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ char *arg1 = (char *) 0 ;
int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamDefTimestep",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefTimestep" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefGlobal", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiDefGlobal" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefTimestep" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefGlobal" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)streamDefTimestep(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ cdiDefGlobal((char const *)arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamInqTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_namespaceNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamInqTimestep",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqTimestep" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamInqTimestep" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)streamInqTimestep(arg1,arg2);
+ if (!SWIG_Python_UnpackTuple(args, "namespaceNew", 0, 0, 0)) SWIG_fail;
+ result = (int)namespaceNew();
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -3321,135 +3720,141 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_namespaceSetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- char *result = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamFilename",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamFilename" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "namespaceSetActive" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (char *)streamFilename(arg1);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ namespaceSetActive(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamFilesuffix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_namespaceGetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- char *result = 0 ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamFilesuffix",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamFilesuffix" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- result = (char *)streamFilesuffix(arg1);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ if (!SWIG_Python_UnpackTuple(args, "namespaceGetActive", 0, 0, 0)) SWIG_fail;
+ result = (int)namespaceGetActive();
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_namespaceDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamNtsteps",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamNtsteps" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "namespaceDelete" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)streamNtsteps(arg1);
- resultobj = SWIG_From_int((int)(result));
+ namespaceDelete(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamNvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiParamToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- off_t result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"O:streamNvals",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiParamToString", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamNvals" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiParamToString" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = streamNvals(arg1);
- resultobj = SWIG_NewPointerObj((off_t *)memcpy((off_t *)malloc(sizeof(off_t)),&result,sizeof(off_t)), SWIGTYPE_p_off_t, SWIG_POINTER_OWN | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiParamToString" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiParamToString" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ cdiParamToString(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamReadVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDecodeParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- double *arg3 = (double *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:streamReadVar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDecodeParam", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDecodeParam" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVar" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiDecodeParam" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadVar" "', argument " "3"" of type '" "double *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDecodeParam" "', argument " "3"" of type '" "int *""'");
}
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVar" "', argument " "4"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiDecodeParam" "', argument " "4"" of type '" "int *""'");
}
arg4 = (int *)(argp4);
- streamReadVar(arg1,arg2,arg3,arg4);
+ cdiDecodeParam(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3457,104 +3862,88 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamWriteVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiEncodeParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- double *arg3 = (double *) 0 ;
- int arg4 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:streamWriteVar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiEncodeParam", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiEncodeParam" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiEncodeParam" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamWriteVar" "', argument " "3"" of type '" "double const *""'");
- }
- arg3 = (double *)(argp3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streamWriteVar" "', argument " "4"" of type '" "int""'");
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiEncodeParam" "', argument " "3"" of type '" "int""'");
}
- arg4 = (int)(val4);
- streamWriteVar(arg1,arg2,(double const *)arg3,arg4);
- resultobj = SWIG_Py_Void();
+ arg3 = (int)(val3);
+ result = (int)cdiEncodeParam(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamReadVarSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDecodeDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int arg3 ;
- double *arg4 = (double *) 0 ;
- int *arg5 = (int *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ int64_t arg1 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:streamReadVarSlice",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarSlice" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarSlice" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamReadVarSlice" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVarSlice" "', argument " "4"" of type '" "double *""'");
+ if (!SWIG_Python_UnpackTuple(args, "cdiDecodeDate", 4, 4, swig_obj)) SWIG_fail;
+ {
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiDecodeDate" "', argument " "1"" of type '" "int64_t""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cdiDecodeDate" "', argument " "1"" of type '" "int64_t""'");
+ } else {
+ arg1 = *((int64_t *)(argp1));
+ }
}
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "streamReadVarSlice" "', argument " "5"" of type '" "int *""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiDecodeDate" "', argument " "2"" of type '" "int *""'");
}
- arg5 = (int *)(argp5);
- streamReadVarSlice(arg1,arg2,arg3,arg4,arg5);
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDecodeDate" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiDecodeDate" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ cdiDecodeDate(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3562,95 +3951,82 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamWriteVarSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiEncodeDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
- double *arg4 = (double *) 0 ;
- int arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int val5 ;
- int ecode5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
+ PyObject *swig_obj[3] ;
+ int64_t result;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:streamWriteVarSlice",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiEncodeDate", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVarSlice" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiEncodeDate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVarSlice" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiEncodeDate" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteVarSlice" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiEncodeDate" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamWriteVarSlice" "', argument " "4"" of type '" "double const *""'");
- }
- arg4 = (double *)(argp4);
- ecode5 = SWIG_AsVal_int(obj4, &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamWriteVarSlice" "', argument " "5"" of type '" "int""'");
- }
- arg5 = (int)(val5);
- streamWriteVarSlice(arg1,arg2,arg3,(double const *)arg4,arg5);
- resultobj = SWIG_Py_Void();
+ result = cdiEncodeDate(arg1,arg2,arg3);
+ resultobj = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamInqRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDecodeTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int *arg2 = (int *) 0 ;
int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamInqRecord",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDecodeTime", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqRecord" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDecodeTime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqRecord" "', argument " "2"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiDecodeTime" "', argument " "2"" of type '" "int *""'");
}
arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamInqRecord" "', argument " "3"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDecodeTime" "', argument " "3"" of type '" "int *""'");
}
arg3 = (int *)(argp3);
- streamInqRecord(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiDecodeTime" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ cdiDecodeTime(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3658,7 +4034,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamDefRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiEncodeTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -3669,208 +4045,166 @@ SWIGINTERN PyObject *_wrap_streamDefRecord(PyObject *SWIGUNUSEDPARM(self), PyObj
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamDefRecord",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiEncodeTime", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefRecord" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiEncodeTime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefRecord" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiEncodeTime" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamDefRecord" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiEncodeTime" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- streamDefRecord(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ result = (int)cdiEncodeTime(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamReadRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiGetFiletype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- double *arg2 = (double *) 0 ;
- int *arg3 = (int *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
+ char *arg1 = (char *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamReadRecord",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadRecord" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamReadRecord" "', argument " "2"" of type '" "double *""'");
+ if (!SWIG_Python_UnpackTuple(args, "cdiGetFiletype", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGetFiletype" "', argument " "1"" of type '" "char const *""'");
}
- arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadRecord" "', argument " "3"" of type '" "int *""'");
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGetFiletype" "', argument " "2"" of type '" "int *""'");
}
- arg3 = (int *)(argp3);
- streamReadRecord(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ arg2 = (int *)(argp2);
+ result = (int)cdiGetFiletype((char const *)arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamWriteRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamOpenRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- double *arg2 = (double *) 0 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamWriteRecord",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteRecord" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamWriteRecord" "', argument " "2"" of type '" "double const *""'");
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenRead" "', argument " "1"" of type '" "char const *""'");
}
- arg2 = (double *)(argp2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteRecord" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- streamWriteRecord(arg1,(double const *)arg2,arg3);
- resultobj = SWIG_Py_Void();
+ arg1 = (char *)(buf1);
+ result = (int)streamOpenRead((char const *)arg1);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamCopyRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamOpenWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
+ char *arg1 = (char *) 0 ;
int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamCopyRecord",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamCopyRecord" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ if (!SWIG_Python_UnpackTuple(args, "streamOpenWrite", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenWrite" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamCopyRecord" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamOpenWrite" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- streamCopyRecord(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_streamInqGinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int *arg2 = (int *) 0 ;
- float *arg3 = (float *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamInqGinfo",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqGinfo" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqGinfo" "', argument " "2"" of type '" "int *""'");
- }
- arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamInqGinfo" "', argument " "3"" of type '" "float *""'");
- }
- arg3 = (float *)(argp3);
- streamInqGinfo(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ result = (int)streamOpenWrite((char const *)arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamOpenAppend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)":vlistCreate")) SWIG_fail;
- result = (int)vlistCreate();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streamOpenAppend" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (int)streamOpenAppend((char const *)arg1);
resultobj = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamClose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistDestroy",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDestroy" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamClose" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- vlistDestroy(arg1);
+ streamClose(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3878,29 +4212,29 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamSync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistDuplicate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDuplicate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamSync" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistDuplicate(arg1);
- resultobj = SWIG_From_int((int)(result));
+ streamSync(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefNumWorker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -3908,21 +4242,20 @@ SWIGINTERN PyObject *_wrap_vlistCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *a
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistCopy",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefNumWorker", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCopy" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefNumWorker" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCopy" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefNumWorker" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistCopy(arg1,arg2);
+ streamDefNumWorker(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3930,7 +4263,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistCopyFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefVlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -3938,21 +4271,20 @@ SWIGINTERN PyObject *_wrap_vlistCopyFlag(PyObject *SWIGUNUSEDPARM(self), PyObjec
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistCopyFlag",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefVlist", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCopyFlag" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefVlist" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCopyFlag" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefVlist" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistCopyFlag(arg1,arg2);
+ streamDefVlist(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -3960,58 +4292,53 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistClearFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqVlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistClearFlag",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistClearFlag" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqVlist" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- vlistClearFlag(arg1);
- resultobj = SWIG_Py_Void();
+ result = (int)streamInqVlist(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistCat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqFiletype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistCat",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCat" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqFiletype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCat" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- vlistCat(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)streamInqFiletype(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistMerge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefByteorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -4019,42 +4346,20 @@ SWIGINTERN PyObject *_wrap_vlistMerge(PyObject *SWIGUNUSEDPARM(self), PyObject *
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistMerge",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefByteorder", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMerge" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefByteorder" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMerge" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefByteorder" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistMerge(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vlistPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:vlistPrint",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistPrint" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- vlistPrint(arg1);
+ streamDefByteorder(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4062,21 +4367,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistNvars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqByteorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistNvars",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNvars" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqByteorder" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistNvars(arg1);
+ result = (int)streamInqByteorder(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4084,43 +4390,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistNgrids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefCompType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistNgrids",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefCompType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNgrids" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefCompType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistNgrids(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefCompType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ streamDefCompType(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistNzaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqCompType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistNzaxis",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNzaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqCompType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistNzaxis(arg1);
+ result = (int)streamInqCompType(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4128,7 +4442,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDefNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefCompLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -4136,21 +4450,20 @@ SWIGINTERN PyObject *_wrap_vlistDefNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObj
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistDefNtsteps",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefCompLevel", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefNtsteps" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefCompLevel" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefNtsteps" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefCompLevel" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistDefNtsteps(arg1,arg2);
+ streamDefCompLevel(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4158,21 +4471,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqCompLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistNtsteps",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNtsteps" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqCompLevel" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistNtsteps(arg1);
+ result = (int)streamInqCompLevel(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4180,21 +4494,29 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistGridsizeMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistGridsizeMax",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefTimestep", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGridsizeMax" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefTimestep" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistGridsizeMax(arg1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefTimestep" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)streamDefTimestep(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4202,7 +4524,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -4210,22 +4532,21 @@ SWIGINTERN PyObject *_wrap_vlistGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *a
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistGrid",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamInqTimestep", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGrid" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqTimestep" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistGrid" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamInqTimestep" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistGrid(arg1,arg2);
+ result = (int)streamInqTimestep(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4233,30 +4554,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistGridIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqCurTimestepID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistGridIndex",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGridIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqCurTimestepID" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistGridIndex" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistGridIndex(arg1,arg2);
+ result = (int)streamInqCurTimestepID(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4264,139 +4577,91 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistChangeGridIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeGridIndex",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeGridIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamFilename" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeGridIndex" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeGridIndex" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistChangeGridIndex(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ result = (char *)streamFilename(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistChangeGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamFilesuffix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeGrid",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeGrid" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamFilesuffix" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeGrid" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeGrid" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistChangeGrid(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ result = (char *)streamFilesuffix(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamNvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistZaxis",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistZaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamNvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistZaxis" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistZaxis(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ result = streamNvals(arg1);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistZaxisIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqNvars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistZaxisIndex",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistZaxisIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqNvars" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistZaxisIndex" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistZaxisIndex(arg1,arg2);
+ result = (int)streamInqNvars(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -4404,38 +4669,44 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistChangeZaxisIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ double *arg3 ;
+ size_t arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ size_t val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeZaxisIndex",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteVar", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeZaxisIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeZaxisIndex" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVar" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeZaxisIndex" "', argument " "3"" of type '" "int""'");
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamWriteVar" "', argument " "3"" of type '" "double const []""'");
}
- arg3 = (int)(val3);
- vlistChangeZaxisIndex(arg1,arg2,arg3);
+ arg3 = (double *)(argp3);
+ ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streamWriteVar" "', argument " "4"" of type '" "size_t""'");
+ }
+ arg4 = (size_t)(val4);
+ streamWriteVar(arg1,arg2,(double const (*))arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4443,38 +4714,44 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistChangeZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteVarF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int arg3 ;
+ float *arg3 ;
+ size_t arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ size_t val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeZaxis",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteVarF", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeZaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVarF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeZaxis" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVarF" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeZaxis" "', argument " "3"" of type '" "int""'");
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamWriteVarF" "', argument " "3"" of type '" "float const []""'");
}
- arg3 = (int)(val3);
- vlistChangeZaxis(arg1,arg2,arg3);
+ arg3 = (float *)(argp3);
+ ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streamWriteVarF" "', argument " "4"" of type '" "size_t""'");
+ }
+ arg4 = (size_t)(val4);
+ streamWriteVarF(arg1,arg2,(float const (*))arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4482,242 +4759,288 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistNrecs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
+ double *arg3 ;
+ size_t *arg4 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"O:vlistNrecs",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVar", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNrecs" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)vlistNrecs(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVar" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadVar" "', argument " "3"" of type '" "double []""'");
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVar" "', argument " "4"" of type '" "size_t *""'");
+ }
+ arg4 = (size_t *)(argp4);
+ streamReadVar(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefTaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVarF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ float *arg3 ;
+ size_t *arg4 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistDefTaxis",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVarF", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefTaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefTaxis" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarF" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistDefTaxis(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vlistInqTaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:vlistInqTaxis",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqTaxis" "', argument " "1"" of type '" "int""'");
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadVarF" "', argument " "3"" of type '" "float []""'");
}
- arg1 = (int)(val1);
- result = (int)vlistInqTaxis(arg1);
- resultobj = SWIG_From_int((int)(result));
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVarF" "', argument " "4"" of type '" "size_t *""'");
+ }
+ arg4 = (size_t *)(argp4);
+ streamReadVarF(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVarPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ size_t arg5 ;
+ void *arg6 = (void *) 0 ;
+ size_t *arg7 = (size_t *) 0 ;
+ int arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ int res6 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ int val8 ;
+ int ecode8 = 0 ;
+ PyObject *swig_obj[8] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistDefTable",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVarPart", 8, 8, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefTable" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarPart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefTable" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarPart" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistDefTable(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vlistInqTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:vlistInqTable",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqTable" "', argument " "1"" of type '" "int""'");
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamReadVarPart" "', argument " "3"" of type '" "int""'");
}
- arg1 = (int)(val1);
- result = (int)vlistInqTable(arg1);
- resultobj = SWIG_From_int((int)(result));
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streamReadVarPart" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamReadVarPart" "', argument " "5"" of type '" "size_t""'");
+ }
+ arg5 = (size_t)(val5);
+ res6 = SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&arg6), 0, 0);
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "streamReadVarPart" "', argument " "6"" of type '" "void *""'");
+ }
+ res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "streamReadVarPart" "', argument " "7"" of type '" "size_t *""'");
+ }
+ arg7 = (size_t *)(argp7);
+ ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "streamReadVarPart" "', argument " "8"" of type '" "int""'");
+ }
+ arg8 = (int)(val8);
+ streamReadVarPart(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteVarSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ double *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistDefInstitut",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteVarSlice", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefInstitut" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVarSlice" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefInstitut" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVarSlice" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistDefInstitut(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vlistInqInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:vlistInqInstitut",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqInstitut" "', argument " "1"" of type '" "int""'");
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteVarSlice" "', argument " "3"" of type '" "int""'");
}
- arg1 = (int)(val1);
- result = (int)vlistInqInstitut(arg1);
- resultobj = SWIG_From_int((int)(result));
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamWriteVarSlice" "', argument " "4"" of type '" "double const []""'");
+ }
+ arg4 = (double *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamWriteVarSlice" "', argument " "5"" of type '" "size_t""'");
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarSlice(arg1,arg2,arg3,(double const (*))arg4,arg5);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteVarSliceF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ float *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistDefModel",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteVarSliceF", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefModel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVarSliceF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefModel" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVarSliceF" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- vlistDefModel(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vlistInqModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:vlistInqModel",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqModel" "', argument " "1"" of type '" "int""'");
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteVarSliceF" "', argument " "3"" of type '" "int""'");
}
- arg1 = (int)(val1);
- result = (int)vlistInqModel(arg1);
- resultobj = SWIG_From_int((int)(result));
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamWriteVarSliceF" "', argument " "4"" of type '" "float const []""'");
+ }
+ arg4 = (float *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamWriteVarSliceF" "', argument " "5"" of type '" "size_t""'");
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarSliceF(arg1,arg2,arg3,(float const (*))arg4,arg5);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVarSlicePart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
int arg4 ;
+ int arg5 ;
+ size_t arg6 ;
+ void *arg7 = (void *) 0 ;
+ size_t *arg8 = (size_t *) 0 ;
+ int arg9 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4726,73 +5049,116 @@ SWIGINTERN PyObject *_wrap_vlistDefVar(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- int result;
+ int val5 ;
+ int ecode5 = 0 ;
+ size_t val6 ;
+ int ecode6 = 0 ;
+ int res7 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ int val9 ;
+ int ecode9 = 0 ;
+ PyObject *swig_obj[9] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:vlistDefVar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVarSlicePart", 9, 9, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarSlicePart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarSlicePart" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVar" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamReadVarSlicePart" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefVar" "', argument " "4"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streamReadVarSlicePart" "', argument " "4"" of type '" "int""'");
}
arg4 = (int)(val4);
- result = (int)vlistDefVar(arg1,arg2,arg3,arg4);
- resultobj = SWIG_From_int((int)(result));
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamReadVarSlicePart" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_size_t(swig_obj[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "streamReadVarSlicePart" "', argument " "6"" of type '" "size_t""'");
+ }
+ arg6 = (size_t)(val6);
+ res7 = SWIG_ConvertPtr(swig_obj[6],SWIG_as_voidptrptr(&arg7), 0, 0);
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "streamReadVarSlicePart" "', argument " "7"" of type '" "void *""'");
+ }
+ res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "streamReadVarSlicePart" "', argument " "8"" of type '" "size_t *""'");
+ }
+ arg8 = (size_t *)(argp8);
+ ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "streamReadVarSlicePart" "', argument " "9"" of type '" "int""'");
+ }
+ arg9 = (int)(val9);
+ streamReadVarSlicePart(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistChangeVarGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVarSlice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ double *arg4 ;
+ size_t *arg5 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeVarGrid",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVarSlice", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeVarGrid" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarSlice" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeVarGrid" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarSlice" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeVarGrid" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamReadVarSlice" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- vlistChangeVarGrid(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVarSlice" "', argument " "4"" of type '" "double []""'");
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "streamReadVarSlice" "', argument " "5"" of type '" "size_t *""'");
+ }
+ arg5 = (size_t *)(argp5);
+ streamReadVarSlice(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4800,38 +5166,52 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistChangeVarZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadVarSliceF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ float *arg4 ;
+ size_t *arg5 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistChangeVarZaxis",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadVarSliceF", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeVarZaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadVarSliceF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeVarZaxis" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamReadVarSliceF" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeVarZaxis" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamReadVarSliceF" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- vlistChangeVarZaxis(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamReadVarSliceF" "', argument " "4"" of type '" "float []""'");
+ }
+ arg4 = (float *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "streamReadVarSliceF" "', argument " "5"" of type '" "size_t *""'");
+ }
+ arg5 = (size_t *)(argp5);
+ streamReadVarSliceF(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4839,13 +5219,13 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteVarChunk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 = (int *) 0 ;
- int *arg4 = (int *) 0 ;
- int *arg5 = (int *) 0 ;
+ int (*arg3)[2] ;
+ double *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -4854,41 +5234,37 @@ SWIGINTERN PyObject *_wrap_vlistInqVar(PyObject *SWIGUNUSEDPARM(self), PyObject
int res3 = 0 ;
void *argp4 = 0 ;
int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistInqVar",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteVarChunk", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteVarChunk" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamWriteVarChunk" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_a_2__int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVar" "', argument " "3"" of type '" "int *""'");
- }
- arg3 = (int *)(argp3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamWriteVarChunk" "', argument " "3"" of type '" "int const [3][2]""'");
+ }
+ arg3 = (int (*)[2])(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vlistInqVar" "', argument " "4"" of type '" "int *""'");
- }
- arg4 = (int *)(argp4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqVar" "', argument " "5"" of type '" "int *""'");
- }
- arg5 = (int *)(argp5);
- vlistInqVar(arg1,arg2,arg3,arg4,arg5);
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamWriteVarChunk" "', argument " "4"" of type '" "double const []""'");
+ }
+ arg4 = (double *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "streamWriteVarChunk" "', argument " "5"" of type '" "size_t""'");
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarChunk(arg1,arg2,(int const (*)[2])arg3,(double const (*))arg4,arg5);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -4896,131 +5272,147 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamDefRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarGrid",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamDefRecord", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarGrid" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefRecord" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarGrid" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefRecord" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistInqVarGrid(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamDefRecord" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ streamDefRecord(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarZaxis",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamInqRecord", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarZaxis" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqRecord" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarZaxis" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarZaxis(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqRecord" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamInqRecord" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ streamInqRecord(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ double *arg2 ;
+ size_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarTime",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteRecord", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTime" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteRecord" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTime" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamWriteRecord" "', argument " "2"" of type '" "double const []""'");
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarTime(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteRecord" "', argument " "3"" of type '" "size_t""'");
+ }
+ arg3 = (size_t)(val3);
+ streamWriteRecord(arg1,(double const (*))arg2,arg3);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarZtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamWriteRecordF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ float *arg2 ;
+ size_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarZtype",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamWriteRecordF", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarZtype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamWriteRecordF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarZtype" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamWriteRecordF" "', argument " "2"" of type '" "float const []""'");
}
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ arg2 = (float *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarZtype" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streamWriteRecordF" "', argument " "3"" of type '" "size_t""'");
}
- arg3 = (int)(val3);
- vlistDefVarZtype(arg1,arg2,arg3);
+ arg3 = (size_t)(val3);
+ streamWriteRecordF(arg1,(float const (*))arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5028,69 +5420,73 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarZtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ double *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarZtype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadRecord", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarZtype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadRecord" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarZtype" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamReadRecord" "', argument " "2"" of type '" "double []""'");
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarZtype(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadRecord" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ streamReadRecord(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarZlevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamReadRecordF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ float *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarZlevel",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamReadRecordF", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarZlevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamReadRecordF" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarZlevel" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarZlevel" "', argument " "3"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamReadRecordF" "', argument " "2"" of type '" "float []""'");
}
- arg3 = (int)(val3);
- vlistDefVarZlevel(arg1,arg2,arg3);
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamReadRecordF" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ streamReadRecordF(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5098,7 +5494,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarZlevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamCopyRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -5106,61 +5502,65 @@ SWIGINTERN PyObject *_wrap_vlistInqVarZlevel(PyObject *SWIGUNUSEDPARM(self), PyO
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarZlevel",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamCopyRecord", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarZlevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamCopyRecord" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarZlevel" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamCopyRecord" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistInqVarZlevel(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ streamCopyRecord(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqGRIBinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ int *arg2 = (int *) 0 ;
+ float *arg3 = (float *) 0 ;
+ off_t *arg4 = (off_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarCode",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamInqGRIBinfo", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarCode" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqGRIBinfo" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarCode" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarCode" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistDefVarCode(arg1,arg2,arg3);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqGRIBinfo" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamInqGRIBinfo" "', argument " "3"" of type '" "float *""'");
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_off_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "streamInqGRIBinfo" "', argument " "4"" of type '" "off_t *""'");
+ }
+ arg4 = (off_t *)(argp4);
+ streamInqGRIBinfo(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5168,209 +5568,5436 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiIterator_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ PyObject *swig_obj[1] ;
+ CdiIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarCode",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarCode" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarCode" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarCode(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_new" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (CdiIterator *)cdiIterator_new((char const *)arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiIterator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ CdiIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarDatatype",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarDatatype" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarDatatype" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarDatatype" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistDefVarDatatype(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_clone" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (CdiIterator *)cdiIterator_clone(arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiIterator_serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarDatatype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarDatatype" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarDatatype" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarDatatype(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_serialize" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_serialize(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiIterator_deserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ PyObject *swig_obj[1] ;
+ CdiIterator *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarInstitut",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarInstitut" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarInstitut" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarInstitut" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistDefVarInstitut(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_deserialize" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ result = (CdiIterator *)cdiIterator_deserialize((char const *)arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiIterator_print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ FILE *arg2 = (FILE *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarInstitut",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarInstitut" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarInstitut" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarInstitut(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_print", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_print" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_print" "', argument " "2"" of type '" "FILE *""'");
+ }
+ arg2 = (FILE *)(argp2);
+ cdiIterator_print(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_delete" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ cdiIterator_delete(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_nextField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_nextField" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_nextField(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqStartTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqStartTime" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqStartTime(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqEndTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqEndTime" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqEndTime(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqRTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqRTime" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqRTime(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqVTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqVTime" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqVTime(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqLevelType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int arg2 ;
+ char **arg3 = (char **) 0 ;
+ char **arg4 = (char **) 0 ;
+ char **arg5 = (char **) 0 ;
+ char **arg6 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ PyObject *swig_obj[6] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqLevelType", 6, 6, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqLevelType" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiIterator_inqLevelType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqLevelType" "', argument " "3"" of type '" "char **""'");
+ }
+ arg3 = (char **)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiIterator_inqLevelType" "', argument " "4"" of type '" "char **""'");
+ }
+ arg4 = (char **)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiIterator_inqLevelType" "', argument " "5"" of type '" "char **""'");
+ }
+ arg5 = (char **)(argp5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cdiIterator_inqLevelType" "', argument " "6"" of type '" "char **""'");
+ }
+ arg6 = (char **)(argp6);
+ result = (int)cdiIterator_inqLevelType(arg1,arg2,arg3,arg4,arg5,arg6);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int arg2 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqLevel", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqLevel" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiIterator_inqLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqLevel" "', argument " "3"" of type '" "double *""'");
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiIterator_inqLevel" "', argument " "4"" of type '" "double *""'");
+ }
+ arg4 = (double *)(argp4);
+ result = (int)cdiIterator_inqLevel(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqLevelUuid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ unsigned char *arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqLevelUuid", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqLevelUuid" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_inqLevelUuid" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqLevelUuid" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiIterator_inqLevelUuid" "', argument " "4"" of type '" "unsigned char [16]""'");
+ }
+ arg4 = (unsigned char *)(argp4);
+ result = (int)cdiIterator_inqLevelUuid(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqTile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqTile", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqTile" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_inqTile" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqTile" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiIterator_inqTile(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqTileCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqTileCount", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqTileCount" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_inqTileCount" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqTileCount" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiIterator_inqTileCount(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ CdiParam result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqParam" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = cdiIterator_inqParam(arg1);
+ resultobj = SWIG_NewPointerObj((CdiParam *)memcpy((CdiParam *)calloc(1,sizeof(CdiParam)),&result,sizeof(CdiParam)), SWIGTYPE_p_CdiParam, SWIG_POINTER_OWN | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqParamParts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_inqParamParts", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqParamParts" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_inqParamParts" "', argument " "2"" of type '" "int *""'");
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_inqParamParts" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiIterator_inqParamParts" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ cdiIterator_inqParamParts(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqDatatype" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqDatatype(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqFiletype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqFiletype" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqFiletype(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqTsteptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqTsteptype" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqTsteptype(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqVariableName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqVariableName" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqVariableName(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_inqGridId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_inqGridId" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqGridId(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_readField(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ double *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_readField", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_readField" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_readField" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_readField" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ cdiIterator_readField(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiIterator_readFieldF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ float *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiIterator_readFieldF", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiIterator_readFieldF" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiIterator_readFieldF" "', argument " "2"" of type '" "float []""'");
+ }
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiIterator_readFieldF" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ cdiIterator_readFieldF(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ CdiGribIterator *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_clone" "', argument " "1"" of type '" "CdiIterator *""'");
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (CdiGribIterator *)cdiGribIterator_clone(arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_delete" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ cdiGribIterator_delete(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long *arg3 = (long *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getLong", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getLong" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getLong" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_long, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getLong" "', argument " "3"" of type '" "long *""'");
+ }
+ arg3 = (long *)(argp3);
+ result = (int)cdiGribIterator_getLong(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double *arg3 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getDouble", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getDouble" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getDouble" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getDouble" "', argument " "3"" of type '" "double *""'");
+ }
+ arg3 = (double *)(argp3);
+ result = (int)cdiGribIterator_getDouble(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getLength", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getLength" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getLength" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getLength" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ result = (int)cdiGribIterator_getLength(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ char *arg3 = (char *) 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getString", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getString" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getString" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getString" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiGribIterator_getString" "', argument " "4"" of type '" "size_t *""'");
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getString(arg1,(char const *)arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getSize", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getSize" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getSize" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getSize" "', argument " "3"" of type '" "size_t *""'");
+ }
+ arg3 = (size_t *)(argp3);
+ result = (int)cdiGribIterator_getSize(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getLongArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long *arg3 = (long *) 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getLongArray", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getLongArray" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getLongArray" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_long, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getLongArray" "', argument " "3"" of type '" "long *""'");
+ }
+ arg3 = (long *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiGribIterator_getLongArray" "', argument " "4"" of type '" "size_t *""'");
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getLongArray(arg1,(char const *)arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_getDoubleArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double *arg3 = (double *) 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_getDoubleArray", 4, 4, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_getDoubleArray" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_getDoubleArray" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiGribIterator_getDoubleArray" "', argument " "3"" of type '" "double *""'");
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiGribIterator_getDoubleArray" "', argument " "4"" of type '" "size_t *""'");
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getDoubleArray(arg1,(char const *)arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqEdition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqEdition" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ result = (int)cdiGribIterator_inqEdition(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqLongValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+ long result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_inqLongValue", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqLongValue" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_inqLongValue" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (long)cdiGribIterator_inqLongValue(arg1,(char const *)arg2);
+ resultobj = SWIG_From_long((long)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqLongDefaultValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ long val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ long result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_inqLongDefaultValue", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqLongDefaultValue" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_inqLongDefaultValue" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_long(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiGribIterator_inqLongDefaultValue" "', argument " "3"" of type '" "long""'");
+ }
+ arg3 = (long)(val3);
+ result = (long)cdiGribIterator_inqLongDefaultValue(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_long((long)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqDoubleValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_inqDoubleValue", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqDoubleValue" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_inqDoubleValue" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (double)cdiGribIterator_inqDoubleValue(arg1,(char const *)arg2);
+ resultobj = SWIG_From_double((double)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqDoubleDefaultValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_inqDoubleDefaultValue", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqDoubleDefaultValue" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_inqDoubleDefaultValue" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiGribIterator_inqDoubleDefaultValue" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ result = (double)cdiGribIterator_inqDoubleDefaultValue(arg1,(char const *)arg2,arg3);
+ resultobj = SWIG_From_double((double)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiGribIterator_inqStringValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+ char *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiGribIterator_inqStringValue", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiGribIterator_inqStringValue" "', argument " "1"" of type '" "CdiGribIterator *""'");
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cdiGribIterator_inqStringValue" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ result = (char *)cdiGribIterator_inqStringValue(arg1,(char const *)arg2);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistCreate", 0, 0, 0)) SWIG_fail;
+ result = (int)vlistCreate();
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDestroy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ vlistDestroy(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDuplicate" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistDuplicate(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistCopy", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCopy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCopy" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistCopy(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistCopyFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistCopyFlag", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCopyFlag" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCopyFlag" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistCopyFlag(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistClearFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistClearFlag" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ vlistClearFlag(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistCat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistCat", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCat" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCat" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistCat(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistMerge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistMerge", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMerge" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMerge" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistMerge(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistPrint" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ vlistPrint(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNumber" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNumber(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNvars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNvars" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNvars(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNgrids(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNgrids" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNgrids(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNzaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNzaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNzaxis(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNsubtypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNsubtypes" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNsubtypes(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefNtsteps", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefNtsteps" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefNtsteps" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistDefNtsteps(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNtsteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNtsteps" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNtsteps(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistGridsizeMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ size_t result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGridsizeMax" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = vlistGridsizeMax(arg1);
+ resultobj = SWIG_From_size_t((size_t)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistGrid", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGrid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistGrid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistGrid(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistGridIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistGridIndex", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistGridIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistGridIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistGridIndex(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeGridIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeGridIndex", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeGridIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeGridIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeGridIndex" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeGridIndex(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeGrid", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeGrid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeGrid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeGrid" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeGrid(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistZaxis", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistZaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistZaxis" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistZaxis(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistZaxisIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistZaxisIndex", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistZaxisIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistZaxisIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistZaxisIndex(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeZaxisIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeZaxisIndex", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeZaxisIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeZaxisIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeZaxisIndex" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeZaxisIndex(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeZaxis", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeZaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeZaxis" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeZaxis" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeZaxis(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistNrecs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistNrecs" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistNrecs(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistSubtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistSubtype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistSubtype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistSubtype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistSubtype(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistSubtypeIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistSubtypeIndex", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistSubtypeIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistSubtypeIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistSubtypeIndex(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefTaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefTaxis", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefTaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefTaxis" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistDefTaxis(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqTaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqTaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistInqTaxis(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefTable", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefTable" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefTable" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistDefTable(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqTable" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistInqTable(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefInstitut", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefInstitut" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefInstitut" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistDefInstitut(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqInstitut" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistInqInstitut(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefModel", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefModel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefModel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ vlistDefModel(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqModel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)vlistInqModel(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarTiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarTiles", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTiles" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTiles" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTiles" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefVarTiles" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "vlistDefVarTiles" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = (int)vlistDefVarTiles(arg1,arg2,arg3,arg4,arg5);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVar", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVar" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVar" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVar" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefVar" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)vlistDefVar(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeVarGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeVarGrid", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeVarGrid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeVarGrid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeVarGrid" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeVarGrid(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistChangeVarZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistChangeVarZaxis", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistChangeVarZaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistChangeVarZaxis" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistChangeVarZaxis" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistChangeVarZaxis(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int *arg5 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVar", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVar" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVar" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVar" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vlistInqVar" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqVar" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ vlistInqVar(arg1,arg2,arg3,arg4,arg5);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarGrid", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarGrid" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarGrid" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarGrid(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarZaxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarZaxis", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarZaxis" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarZaxis" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarZaxis(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarID", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarID" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarID" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarID(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarTimetype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarTimetype", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTimetype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTimetype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTimetype" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTimetype(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarTimetype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarTimetype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTimetype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTimetype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTimetype(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarTsteptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarTsteptype", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTsteptype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTsteptype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTsteptype" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTsteptype(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarTsteptype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarTsteptype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTsteptype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTsteptype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTsteptype(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarCompType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarCompType", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarCompType" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarCompType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarCompType" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCompType(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarCompType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarCompType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarCompType" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarCompType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCompType(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarCompLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarCompLevel", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarCompLevel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarCompLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarCompLevel" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCompLevel(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarCompLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarCompLevel", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarCompLevel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarCompLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCompLevel(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarParam", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarParam" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarParam" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarParam" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarParam(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarParam", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarParam" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarParam" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarParam(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarCode", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarCode" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarCode" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarCode" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCode(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarCode", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarCode" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarCode" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCode(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarDatatype", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarDatatype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarDatatype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarDatatype" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarDatatype(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarDatatype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarDatatype" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarDatatype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarDatatype(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarChunkType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarChunkType", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarChunkType" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarChunkType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarChunkType" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarChunkType(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarChunkType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarChunkType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarChunkType" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarChunkType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarChunkType(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarXYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarXYZ", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarXYZ" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarXYZ" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarXYZ" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarXYZ(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarXYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarXYZ", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarXYZ" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarXYZ" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarXYZ(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarNumber", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarNumber" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarNumber" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarNumber(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarInstitut", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarInstitut" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarInstitut" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarInstitut" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarInstitut(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarInstitut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarInstitut", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarInstitut" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarInstitut" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarInstitut(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarModel", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarModel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarModel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarModel" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarModel(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarModel", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarModel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarModel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarModel(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarTable", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTable" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTable" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTable" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTable(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarTable", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTable" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTable" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTable(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarName", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarName" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarName" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarName" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarName(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarName", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarName" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarName" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarName" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarName(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistCopyVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ char *result = 0 ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistCopyVarName", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistCopyVarName" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistCopyVarName" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (char *)vlistCopyVarName(arg1,arg2);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarStdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarStdname", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarStdname" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarStdname" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarStdname" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarStdname(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarStdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarStdname", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarStdname" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarStdname" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarStdname" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarStdname(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarLongname", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarLongname" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarLongname" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarLongname" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarLongname(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarLongname", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarLongname" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarLongname" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarLongname" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarLongname(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarUnits", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarUnits" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarUnits" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarUnits" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarUnits(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarUnits", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarUnits" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarUnits" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarUnits" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarUnits(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarMissval", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarMissval" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarMissval" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarMissval" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ vlistDefVarMissval(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarMissval", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarMissval" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarMissval" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarMissval(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarExtra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarExtra", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarExtra" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarExtra" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarExtra" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarExtra(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarExtra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarExtra", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarExtra" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarExtra" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarExtra" "', argument " "3"" of type '" "char *""'");
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarExtra(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarScalefactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarScalefactor", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarScalefactor" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarScalefactor" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarScalefactor" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ vlistDefVarScalefactor(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarScalefactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarScalefactor", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarScalefactor" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarScalefactor" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarScalefactor(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarAddoffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarAddoffset", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarAddoffset" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarAddoffset" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarAddoffset" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ vlistDefVarAddoffset(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarAddoffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarAddoffset", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarAddoffset" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarAddoffset" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarAddoffset(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarTimave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarTimave", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTimave" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTimave" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTimave" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTimave(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarTimave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarTimave", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTimave" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTimave" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTimave(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarSize", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarSize" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarSize" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = vlistInqVarSize(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefIndex", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefIndex" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefIndex" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ vlistDefIndex(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqIndex", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqIndex" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqIndex" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistInqIndex" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistInqIndex(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefFlag", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefFlag" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefFlag" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefFlag" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefFlag" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ vlistDefFlag(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqFlag", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqFlag" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqFlag" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistInqFlag" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistInqFlag(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistFindVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistFindVar", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistFindVar" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistFindVar" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistFindVar(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistFindLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistFindLevel", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistFindLevel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistFindLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistFindLevel" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistFindLevel(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistMergedVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistMergedVar", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMergedVar" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMergedVar" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistMergedVar(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistMergedLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistMergedLevel", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMergedLevel" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMergedLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistMergedLevel" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistMergedLevel(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiClearAdditionalKeys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiClearAdditionalKeys", 0, 0, 0)) SWIG_fail;
+ cdiClearAdditionalKeys();
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDefAdditionalKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdiDefAdditionalKey" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ cdiDefAdditionalKey((char const *)arg1);
+ resultobj = SWIG_Py_Void();
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return resultobj;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarIntKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarIntKey", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarIntKey" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarIntKey" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarIntKey" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefVarIntKey" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ vlistDefVarIntKey(arg1,arg2,(char const *)arg3,arg4);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistDefVarDblKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ double arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistDefVarDblKey", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarDblKey" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarDblKey" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarDblKey" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefVarDblKey" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ vlistDefVarDblKey(arg1,arg2,(char const *)arg3,arg4);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistHasVarKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistHasVarKey", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistHasVarKey" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistHasVarKey" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistHasVarKey" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)vlistHasVarKey(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarDblKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+ double result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarDblKey", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarDblKey" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarDblKey" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarDblKey" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (double)vlistInqVarDblKey(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_From_double((double)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vlistInqVarIntKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarIntKey", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarIntKey" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarIntKey" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarIntKey" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)vlistInqVarIntKey(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqNatts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int *arg3 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqNatts", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqNatts" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqNatts" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiInqNatts" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiInqNatts(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqAtt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int *arg5 = (int *) 0 ;
+ int *arg6 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ PyObject *swig_obj[6] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqAtt", 6, 6, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqAtt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqAtt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiInqAtt" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiInqAtt" "', argument " "4"" of type '" "char *""'");
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqAtt" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cdiInqAtt" "', argument " "6"" of type '" "int *""'");
+ }
+ arg6 = (int *)(argp6);
+ result = (int)cdiInqAtt(arg1,arg2,arg3,arg4,arg5,arg6);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return resultobj;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDelAtt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiDelAtt", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDelAtt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDelAtt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDelAtt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ result = (int)cdiDelAtt(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiCopyAtts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiCopyAtts", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiCopyAtts" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiCopyAtts" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiCopyAtts" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiCopyAtts" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiCopyAtts(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDefAttInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ int *arg6 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ PyObject *swig_obj[6] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefAttInt", 6, 6, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefAttInt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefAttInt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDefAttInt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiDefAttInt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cdiDefAttInt" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cdiDefAttInt" "', argument " "6"" of type '" "int const []""'");
+ }
+ arg6 = (int *)(argp6);
+ result = (int)cdiDefAttInt(arg1,arg2,(char const *)arg3,arg4,arg5,(int const (*))arg6);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDefAttFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ double *arg6 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ PyObject *swig_obj[6] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefAttFlt", 6, 6, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefAttFlt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefAttFlt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDefAttFlt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiDefAttFlt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cdiDefAttFlt" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "cdiDefAttFlt" "', argument " "6"" of type '" "double const []""'");
+ }
+ arg6 = (double *)(argp6);
+ result = (int)cdiDefAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5,(double const (*))arg6);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiDefAttTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefAttTxt", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefAttTxt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefAttTxt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiDefAttTxt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiDefAttTxt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiDefAttTxt" "', argument " "5"" of type '" "char const *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)cdiDefAttTxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqAttInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int *arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqAttInt", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqAttInt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqAttInt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiInqAttInt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiInqAttInt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqAttInt" "', argument " "5"" of type '" "int []""'");
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqAttInt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqAttFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ double *arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqAttFlt", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqAttFlt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqAttFlt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiInqAttFlt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiInqAttFlt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqAttFlt" "', argument " "5"" of type '" "double []""'");
+ }
+ arg5 = (double *)(argp5);
+ result = (int)cdiInqAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_cdiInqAttTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqAttTxt", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqAttTxt" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqAttTxt" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiInqAttTxt" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiInqAttTxt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqAttTxt" "', argument " "5"" of type '" "char *""'");
+ }
+ arg5 = (char *)(buf5);
+ result = (int)cdiInqAttTxt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "gridName", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridName" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridName" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridName(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridNamePtr" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (char *)gridNamePtr(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridCompress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridCompress" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ gridCompress(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridDefMaskGME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "gridDefMaskGME", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefMaskGME" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefMaskGME" "', argument " "2"" of type '" "int const []""'");
+ }
+ arg2 = (int *)(argp2);
+ gridDefMaskGME(arg1,(int const (*))arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqMaskGME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ int *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarModel",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqMaskGME", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarModel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqMaskGME" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarModel" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqMaskGME" "', argument " "2"" of type '" "int []""'");
}
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarModel" "', argument " "3"" of type '" "int""'");
+ arg2 = (int *)(argp2);
+ result = (int)gridInqMaskGME(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridDefMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "gridDefMask", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefMask" "', argument " "1"" of type '" "int""'");
}
- arg3 = (int)(val3);
- vlistDefVarModel(arg1,arg2,arg3);
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefMask" "', argument " "2"" of type '" "int const []""'");
+ }
+ arg2 = (int *)(argp2);
+ gridDefMask(arg1,(int const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5378,30 +11005,29 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ int *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarModel",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqMask", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarModel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqMask" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarModel" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqMask" "', argument " "2"" of type '" "int []""'");
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarModel(arg1,arg2);
+ arg2 = (int *)(argp2);
+ result = (int)gridInqMask(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -5409,38 +11035,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDefVarTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ size_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
+ size_t val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarTable",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridCreate", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTable" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridCreate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTable" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridCreate" "', argument " "2"" of type '" "size_t""'");
}
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTable" "', argument " "3"" of type '" "int""'");
+ arg2 = (size_t)(val2);
+ result = (int)gridCreate(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDestroy" "', argument " "1"" of type '" "int""'");
}
- arg3 = (int)(val3);
- vlistDefVarTable(arg1,arg2,arg3);
+ arg1 = (int)(val1);
+ gridDestroy(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5448,30 +11087,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarTable",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTable" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDuplicate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTable" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarTable(arg1,arg2);
+ result = (int)gridDuplicate(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -5479,374 +11110,305 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDefVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarName",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefProj", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefProj" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarName" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefProj" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarName" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- vlistDefVarName(arg1,arg2,(char const *)arg3);
+ gridDefProj(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqVarName",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqProj" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarName" "', argument " "2"" of type '" "int""'");
+ result = (int)gridInqProj(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridInqProjType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqProjType" "', argument " "1"" of type '" "int""'");
}
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarName" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- vlistInqVarName(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg1 = (int)(val1);
+ result = (int)gridInqProjType(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarLongname",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarLongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarLongname" "', argument " "2"" of type '" "int""'");
+ result = (int)gridInqType(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridInqSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ size_t result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqSize" "', argument " "1"" of type '" "int""'");
}
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarLongname" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- vlistDefVarLongname(arg1,arg2,(char const *)arg3);
- resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg1 = (int)(val1);
+ result = gridInqSize(arg1);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarStdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefXsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
+ size_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
+ size_t val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarStdname",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXsize", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarStdname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXsize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarStdname" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefXsize" "', argument " "2"" of type '" "size_t""'");
}
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarStdname" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- vlistDefVarStdname(arg1,arg2,(char const *)arg3);
+ arg2 = (size_t)(val2);
+ gridDefXsize(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
+ PyObject *swig_obj[1] ;
+ size_t result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXsize" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = gridInqXsize(arg1);
+ resultobj = SWIG_From_size_t((size_t)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridDefYsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqVarLongname",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYsize", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarLongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYsize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarLongname" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefYsize" "', argument " "2"" of type '" "size_t""'");
}
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarLongname" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- vlistInqVarLongname(arg1,arg2,arg3);
+ arg2 = (size_t)(val2);
+ gridDefYsize(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarStdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqVarStdname",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarStdname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYsize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarStdname" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarStdname" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- vlistInqVarStdname(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ result = gridInqYsize(arg1);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefNP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarUnits",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefNP", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarUnits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefNP" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarUnits" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefNP" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefVarUnits" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- vlistDefVarUnits(arg1,arg2,(char const *)arg3);
+ gridDefNP(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqNP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqVarUnits",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarUnits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqNP" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarUnits" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqVarUnits" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- vlistInqVarUnits(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ result = (int)gridInqNP(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefXvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- double arg3 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarMissval",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarMissval" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarMissval" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarMissval" "', argument " "3"" of type '" "double""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXvals" "', argument " "2"" of type '" "double const []""'");
}
- arg3 = (double)(val3);
- vlistDefVarMissval(arg1,arg2,arg3);
+ arg2 = (double *)(argp2);
+ gridDefXvals(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -5854,341 +11416,332 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarMissval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarMissval",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarMissval" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarMissval" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXvals" "', argument " "2"" of type '" "double []""'");
}
- arg2 = (int)(val2);
- result = (double)vlistInqVarMissval(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ arg2 = (double *)(argp2);
+ result = gridInqXvals(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarScalefactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXvalsPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- double arg3 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- double val3 ;
+ size_t val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarScalefactor",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXvalsPart", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarScalefactor" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXvalsPart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarScalefactor" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqXvalsPart" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarScalefactor" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridInqXvalsPart" "', argument " "3"" of type '" "size_t""'");
}
- arg3 = (double)(val3);
- vlistDefVarScalefactor(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqXvalsPart" "', argument " "4"" of type '" "double []""'");
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqXvalsPart(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarScalefactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXIsc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarScalefactor",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarScalefactor" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXIsc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarScalefactor" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (double)vlistInqVarScalefactor(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ result = (int)gridInqXIsc(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarAddoffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXCvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- double arg3 ;
+ char **arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarAddoffset",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXCvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarAddoffset" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXCvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarAddoffset" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarAddoffset" "', argument " "3"" of type '" "double""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXCvals" "', argument " "2"" of type '" "char *[]""'");
}
- arg3 = (double)(val3);
- vlistDefVarAddoffset(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ arg2 = (char **)(argp2);
+ result = gridInqXCvals(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarAddoffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefYvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarAddoffset",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarAddoffset" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarAddoffset" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYvals" "', argument " "2"" of type '" "double const []""'");
}
- arg2 = (int)(val2);
- result = (double)vlistInqVarAddoffset(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ arg2 = (double *)(argp2);
+ gridDefYvals(arg1,(double const (*))arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarTimave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarTimave",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTimave" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTimave" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTimave" "', argument " "3"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYvals" "', argument " "2"" of type '" "double []""'");
}
- arg3 = (int)(val3);
- vlistDefVarTimave(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ arg2 = (double *)(argp2);
+ result = gridInqYvals(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarTimave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYvalsPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarTimave",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYvalsPart", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTimave" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYvalsPart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTimave" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqYvalsPart" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistInqVarTimave(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridInqYvalsPart" "', argument " "3"" of type '" "size_t""'");
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqYvalsPart" "', argument " "4"" of type '" "double []""'");
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqYvalsPart(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefVarTimaccu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYIsc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDefVarTimaccu",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefVarTimaccu" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYIsc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefVarTimaccu" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefVarTimaccu" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
- vlistDefVarTimaccu(arg1,arg2,arg3);
- resultobj = SWIG_Py_Void();
+ result = (int)gridInqYIsc(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarTimaccu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYCvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ char **arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarTimaccu",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYCvals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarTimaccu" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYCvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarTimaccu" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYCvals" "', argument " "2"" of type '" "char *[]""'");
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarTimaccu(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (char **)(argp2);
+ result = gridInqYCvals(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqVarSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDefKeyInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ int arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarSize",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefKeyInt", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarSize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefKeyInt" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarSize" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefKeyInt" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistInqVarSize(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiDefKeyInt" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiDefKeyInt" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiDefKeyInt(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -6196,30 +11749,45 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistInqVarID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiInqKeyInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistInqVarID",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqKeyInt", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarID" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqKeyInt" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarID" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqKeyInt" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistInqVarID(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiInqKeyInt" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiInqKeyInt" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ result = (int)cdiInqKeyInt(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -6227,87 +11795,107 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDefIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDefKeyBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
- int arg4 ;
+ unsigned char *arg4 ;
+ int arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:vlistDefIndex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefKeyBytes", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefKeyBytes" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefIndex" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefKeyBytes" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefIndex" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiDefKeyBytes" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefIndex" "', argument " "4"" of type '" "int""'");
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiDefKeyBytes" "', argument " "4"" of type '" "unsigned char const []""'");
}
- arg4 = (int)(val4);
- vlistDefIndex(arg1,arg2,arg3,arg4);
- resultobj = SWIG_Py_Void();
+ arg4 = (unsigned char *)(argp4);
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "cdiDefKeyBytes" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ result = (int)cdiDefKeyBytes(arg1,arg2,arg3,(unsigned char const (*))arg4,arg5);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiInqKeyBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ unsigned char *arg4 ;
+ int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqIndex",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqKeyBytes", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqIndex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqKeyBytes" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqIndex" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqKeyBytes" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistInqIndex" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiInqKeyBytes" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- result = (int)vlistInqIndex(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiInqKeyBytes" "', argument " "4"" of type '" "unsigned char []""'");
+ }
+ arg4 = (unsigned char *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqKeyBytes" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqKeyBytes(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -6315,118 +11903,151 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDefFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiDefKeyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
- int arg4 ;
+ char *arg4 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:vlistDefFlag",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiDefKeyString", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefFlag" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiDefKeyString" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefFlag" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiDefKeyString" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistDefFlag" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiDefKeyString" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefFlag" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- vlistDefFlag(arg1,arg2,arg3,arg4);
- resultobj = SWIG_Py_Void();
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiDefKeyString" "', argument " "4"" of type '" "char const *""'");
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiDefKeyString(arg1,arg2,arg3,(char const *)arg4);
+ resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiInqKeyString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqFlag",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqKeyString", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqFlag" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqKeyString" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqFlag" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqKeyString" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistInqFlag" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiInqKeyString" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- result = (int)vlistInqFlag(arg1,arg2,arg3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiInqKeyString" "', argument " "4"" of type '" "char *""'");
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "cdiInqKeyString" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqKeyString(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistFindVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiInqKeyLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistFindVar",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiInqKeyLen", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistFindVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiInqKeyLen" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistFindVar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiInqKeyLen" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistFindVar(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiInqKeyLen" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiInqKeyLen" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ result = (int)cdiInqKeyLen(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -6434,39 +12055,45 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistFindLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiCopyKeys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ int arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistFindLevel",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiCopyKeys", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistFindLevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiCopyKeys" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistFindLevel" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiCopyKeys" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistFindLevel" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiCopyKeys" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- result = (int)vlistFindLevel(arg1,arg2,arg3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "cdiCopyKeys" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiCopyKeys(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -6474,125 +12101,159 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistMergedVar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiGridDefKeyStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:vlistMergedVar",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiGridDefKeyStr", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMergedVar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiGridDefKeyStr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMergedVar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiGridDefKeyStr" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)vlistMergedVar(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiGridDefKeyStr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiGridDefKeyStr" "', argument " "4"" of type '" "char const *""'");
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiGridDefKeyStr(arg1,arg2,arg3,(char const *)arg4);
resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistMergedLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiGridInqKeyStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
+ char *arg4 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistMergedLevel",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiGridInqKeyStr", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistMergedLevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiGridInqKeyStr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistMergedLevel" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiGridInqKeyStr" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistMergedLevel" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiGridInqKeyStr" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- result = (int)vlistMergedLevel(arg1,arg2,arg3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiGridInqKeyStr" "', argument " "4"" of type '" "char *""'");
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiGridInqKeyStr(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqNatts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiZaxisDefKeyStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- int *arg3 = (int *) 0 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistInqNatts",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiZaxisDefKeyStr", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqNatts" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiZaxisDefKeyStr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqNatts" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiZaxisDefKeyStr" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqNatts" "', argument " "3"" of type '" "int *""'");
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiZaxisDefKeyStr" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiZaxisDefKeyStr" "', argument " "4"" of type '" "char const *""'");
}
- arg3 = (int *)(argp3);
- result = (int)vlistInqNatts(arg1,arg2,arg3);
+ arg4 = (char *)(buf4);
+ result = (int)cdiZaxisDefKeyStr(arg1,arg2,arg3,(char const *)arg4);
resultobj = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqAtt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiZaxisInqKeyStr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int arg3 ;
char *arg4 = (char *) 0 ;
- int *arg5 = (int *) 0 ;
- int *arg6 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -6602,50 +12263,31 @@ SWIGINTERN PyObject *_wrap_vlistInqAtt(PyObject *SWIGUNUSEDPARM(self), PyObject
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:vlistInqAtt",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiZaxisInqKeyStr", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqAtt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiZaxisInqKeyStr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqAtt" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiZaxisInqKeyStr" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlistInqAtt" "', argument " "3"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiZaxisInqKeyStr" "', argument " "3"" of type '" "int""'");
}
arg3 = (int)(val3);
- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vlistInqAtt" "', argument " "4"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "cdiZaxisInqKeyStr" "', argument " "4"" of type '" "char *""'");
}
arg4 = (char *)(buf4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqAtt" "', argument " "5"" of type '" "int *""'");
- }
- arg5 = (int *)(argp5);
- res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "vlistInqAtt" "', argument " "6"" of type '" "int *""'");
- }
- arg6 = (int *)(argp6);
- result = (int)vlistInqAtt(arg1,arg2,arg3,arg4,arg5,arg6);
+ result = (int)cdiZaxisInqKeyStr(arg1,arg2,arg3,arg4);
resultobj = SWIG_From_int((int)(result));
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return resultobj;
@@ -6655,422 +12297,275 @@ fail:
}
-SWIGINTERN PyObject *_wrap_vlistDelAtt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiZaxisDefKeyFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
+ double arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:vlistDelAtt",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiZaxisDefKeyFlt", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDelAtt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiZaxisDefKeyFlt" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDelAtt" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiZaxisDefKeyFlt" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDelAtt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- result = (int)vlistDelAtt(arg1,arg2,(char const *)arg3);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cdiZaxisDefKeyFlt" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ result = (int)cdiZaxisDefKeyFlt(arg1,arg2,arg3);
resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefAttInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_cdiZaxisInqKeyFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- int *arg5 = (int *) 0 ;
+ double *arg3 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistDefAttInt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "cdiZaxisInqKeyFlt", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefAttInt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cdiZaxisInqKeyFlt" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefAttInt" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdiZaxisInqKeyFlt" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefAttInt" "', argument " "3"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cdiZaxisInqKeyFlt" "', argument " "3"" of type '" "double *""'");
}
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefAttInt" "', argument " "4"" of type '" "int""'");
+ arg3 = (double *)(argp3);
+ result = (int)cdiZaxisInqKeyFlt(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gridDefXname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXname" "', argument " "1"" of type '" "int""'");
}
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistDefAttInt" "', argument " "5"" of type '" "int const *""'");
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXname" "', argument " "2"" of type '" "char const *""'");
}
- arg5 = (int *)(argp5);
- result = (int)vlistDefAttInt(arg1,arg2,(char const *)arg3,arg4,(int const *)arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg2 = (char *)(buf2);
+ gridDefXname(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefAttFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- double *arg5 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistDefAttFlt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefAttFlt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefAttFlt" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefAttFlt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefAttFlt" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistDefAttFlt" "', argument " "5"" of type '" "double const *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXname" "', argument " "2"" of type '" "char *""'");
}
- arg5 = (double *)(argp5);
- result = (int)vlistDefAttFlt(arg1,arg2,(char const *)arg3,arg4,(double const *)arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg2 = (char *)(buf2);
+ gridInqXname(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistDefAttTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefXlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- char *arg5 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistDefAttTxt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXlongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistDefAttTxt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXlongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistDefAttTxt" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistDefAttTxt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistDefAttTxt" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistDefAttTxt" "', argument " "5"" of type '" "char const *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXlongname" "', argument " "2"" of type '" "char const *""'");
}
- arg5 = (char *)(buf5);
- result = (int)vlistDefAttTxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ arg2 = (char *)(buf2);
+ gridDefXlongname(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqAttInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- int *arg5 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistInqAttInt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXlongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqAttInt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXlongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqAttInt" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqAttInt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistInqAttInt" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqAttInt" "', argument " "5"" of type '" "int *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXlongname" "', argument " "2"" of type '" "char *""'");
}
- arg5 = (int *)(argp5);
- result = (int)vlistInqAttInt(arg1,arg2,(char const *)arg3,arg4,arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg2 = (char *)(buf2);
+ gridInqXlongname(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqAttFlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefXunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- double *arg5 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistInqAttFlt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXunits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqAttFlt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXunits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqAttFlt" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqAttFlt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistInqAttFlt" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqAttFlt" "', argument " "5"" of type '" "double *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXunits" "', argument " "2"" of type '" "char const *""'");
}
- arg5 = (double *)(argp5);
- result = (int)vlistInqAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg2 = (char *)(buf2);
+ gridDefXunits(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_vlistInqAttTxt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- char *arg5 = (char *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:vlistInqAttTxt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXunits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqAttTxt" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXunits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqAttTxt" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vlistInqAttTxt" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlistInqAttTxt" "', argument " "4"" of type '" "int""'");
- }
- arg4 = (int)(val4);
- res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "vlistInqAttTxt" "', argument " "5"" of type '" "char *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXunits" "', argument " "2"" of type '" "char *""'");
}
- arg5 = (char *)(buf5);
- result = (int)vlistInqAttTxt(arg1,arg2,(char const *)arg3,arg4,arg5);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ arg2 = (char *)(buf2);
+ gridInqXunits(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefYname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
@@ -7079,21 +12574,20 @@ SWIGINTERN PyObject *_wrap_gridName(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridName",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridName" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYname" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
- gridName(arg1,arg2);
+ gridDefYname(arg1,(char const *)arg2);
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
@@ -7103,242 +12597,275 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- char *result = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridNamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridNamePtr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (char *)gridNamePtr(arg1);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYname" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridInqYname(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridCompress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefYlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridCompress",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYlongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridCompress" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYlongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- gridCompress(arg1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYlongname" "', argument " "2"" of type '" "char const *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridDefYlongname(arg1,(char const *)arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int *arg2 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefMask",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYlongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefMask" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYlongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefMask" "', argument " "2"" of type '" "int const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYlongname" "', argument " "2"" of type '" "char *""'");
}
- arg2 = (int *)(argp2);
- gridDefMask(arg1,(int const *)arg2);
+ arg2 = (char *)(buf2);
+ gridInqYlongname(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefYunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int *arg2 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqMask",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYunits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqMask" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYunits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqMask" "', argument " "2"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYunits" "', argument " "2"" of type '" "char const *""'");
}
- arg2 = (int *)(argp2);
- result = (int)gridInqMask(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (char *)(buf2);
+ gridDefYunits(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridPrint",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYunits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridPrint" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYunits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridPrint" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- gridPrint(arg1,arg2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYunits" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridInqYunits(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)":gridSize")) SWIG_fail;
- result = (int)gridSize();
- resultobj = SWIG_From_int((int)(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_gridCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXstdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridCreate",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXstdname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridCreate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXstdname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridCreate" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (int)gridCreate(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXstdname" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridInqXstdname(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYstdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridDestroy",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYstdname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDestroy" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYstdname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- gridDestroy(arg1);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYstdname" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ gridInqYstdname(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridDuplicate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefDatatype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDuplicate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefDatatype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridDuplicate(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefDatatype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ gridDefDatatype(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqType",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqDatatype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqType(arg1);
+ result = (int)gridInqDatatype(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -7346,125 +12873,128 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ size_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqSize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXval", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqSize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXval" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqSize(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqXval" "', argument " "2"" of type '" "size_t""'");
+ }
+ arg2 = (size_t)(val2);
+ result = (double)gridInqXval(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefXsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ size_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
+ size_t val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXsize",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYval", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXsize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYval" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefXsize" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqYval" "', argument " "2"" of type '" "size_t""'");
}
- arg2 = (int)(val2);
- gridDefXsize(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ arg2 = (size_t)(val2);
+ result = (double)gridInqYval(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXinc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqXsize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXsize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXinc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqXsize(arg1);
- resultobj = SWIG_From_int((int)(result));
+ result = (double)gridInqXinc(arg1);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefYsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYinc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYsize",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYsize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYinc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefYsize" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- gridDefYsize(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (double)gridInqYinc(arg1);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYsize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridIsCircular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqYsize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYsize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridIsCircular" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqYsize(arg1);
+ result = (int)gridIsCircular(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -7472,90 +13002,80 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefXvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXvals",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXvals" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqTrunc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXvals" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- gridDefXvals(arg1,(double const *)arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)gridInqTrunc(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXvals",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefTrunc", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXvals" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefTrunc" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXvals" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- result = (int)gridInqXvals(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefTrunc" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ gridDefTrunc(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefYvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYvals",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefNumber", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYvals" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefNumber" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYvals" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- gridDefYvals(arg1,(double const *)arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefNumber" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ gridDefNumber(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -7563,30 +13083,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqYvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYvals",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYvals" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqNumber" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYvals" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- result = (int)gridInqYvals(arg1,arg2);
+ result = (int)gridInqNumber(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -7594,73 +13106,59 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefXname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefPosition", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefPosition" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXname" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- gridDefXname(arg1,(char const *)arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefPosition" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ gridDefPosition(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefXlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXlongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXlongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqPosition" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXlongname" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- gridDefXlongname(arg1,(char const *)arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ result = (int)gridInqPosition(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefXunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
@@ -7669,21 +13167,20 @@ SWIGINTERN PyObject *_wrap_gridDefXunits(PyObject *SWIGUNUSEDPARM(self), PyObjec
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXunits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefReference", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXunits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefReference" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXunits" "', argument " "2"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefReference" "', argument " "2"" of type '" "char const *""'");
}
arg2 = (char *)(buf2);
- gridDefXunits(arg1,(char const *)arg2);
+ gridDefReference(arg1,(char const *)arg2);
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
@@ -7693,7 +13190,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefYname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
@@ -7702,22 +13199,22 @@ SWIGINTERN PyObject *_wrap_gridDefYname(PyObject *SWIGUNUSEDPARM(self), PyObject
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqReference", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqReference" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYname" "', argument " "2"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqReference" "', argument " "2"" of type '" "char *""'");
}
arg2 = (char *)(buf2);
- gridDefYname(arg1,(char const *)arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)gridInqReference(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
@@ -7726,359 +13223,688 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefYlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefUUID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYlongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefUUID", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYlongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefUUID" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYlongname" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- gridDefYlongname(arg1,(char const *)arg2);
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefUUID" "', argument " "2"" of type '" "unsigned char const [16]""'");
+ }
+ arg2 = (unsigned char *)(argp2);
+ gridDefUUID(arg1,(unsigned char const (*))arg2);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefYunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqUUID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYunits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqUUID", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYunits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqUUID" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYunits" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- gridDefYunits(arg1,(char const *)arg2);
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqUUID" "', argument " "2"" of type '" "unsigned char [16]""'");
+ }
+ arg2 = (unsigned char *)(argp2);
+ gridInqUUID(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefParamRLL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefParamRLL", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefParamRLL" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXname" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- gridInqXname(arg1,arg2);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefParamRLL" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefParamRLL" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefParamRLL" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ gridDefParamRLL(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqParamRLL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 = (double *) 0 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXlongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqParamRLL", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXlongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqParamRLL" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXlongname" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqParamRLL" "', argument " "2"" of type '" "double *""'");
}
- arg2 = (char *)(buf2);
- gridInqXlongname(arg1,arg2);
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqParamRLL" "', argument " "3"" of type '" "double *""'");
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqParamRLL" "', argument " "4"" of type '" "double *""'");
+ }
+ arg4 = (double *)(argp4);
+ gridInqParamRLL(arg1,arg2,arg3,arg4);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXstdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefParamGME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXstdname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefParamGME", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXstdname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefParamGME" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXstdname" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- gridInqXstdname(arg1,arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefParamGME" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefParamGME" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefParamGME" "', argument " "4"" of type '" "int""'");
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gridDefParamGME" "', argument " "5"" of type '" "int""'");
+ }
+ arg5 = (int)(val5);
+ gridDefParamGME(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqParamGME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ PyObject *swig_obj[5] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXunits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqParamGME", 5, 5, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXunits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqParamGME" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXunits" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqParamGME" "', argument " "2"" of type '" "int *""'");
}
- arg2 = (char *)(buf2);
- gridInqXunits(arg1,arg2);
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqParamGME" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqParamGME" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gridInqParamGME" "', argument " "5"" of type '" "int *""'");
+ }
+ arg5 = (int *)(argp5);
+ gridInqParamGME(arg1,arg2,arg3,arg4,arg5);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefParamLCC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double arg8 ;
+ double arg9 ;
+ double arg10 ;
+ double arg11 ;
+ double arg12 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ double val9 ;
+ int ecode9 = 0 ;
+ double val10 ;
+ int ecode10 = 0 ;
+ double val11 ;
+ int ecode11 = 0 ;
+ double val12 ;
+ int ecode12 = 0 ;
+ PyObject *swig_obj[12] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefParamLCC", 12, 12, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefParamLCC" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYname" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- gridInqYname(arg1,arg2);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefParamLCC" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefParamLCC" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefParamLCC" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gridDefParamLCC" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gridDefParamLCC" "', argument " "6"" of type '" "double""'");
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gridDefParamLCC" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gridDefParamLCC" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gridDefParamLCC" "', argument " "9"" of type '" "double""'");
+ }
+ arg9 = (double)(val9);
+ ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gridDefParamLCC" "', argument " "10"" of type '" "double""'");
+ }
+ arg10 = (double)(val10);
+ ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gridDefParamLCC" "', argument " "11"" of type '" "double""'");
+ }
+ arg11 = (double)(val11);
+ ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
+ if (!SWIG_IsOK(ecode12)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gridDefParamLCC" "', argument " "12"" of type '" "double""'");
+ }
+ arg12 = (double)(val12);
+ gridDefParamLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYlongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqParamLCC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double arg2 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ double *arg5 = (double *) 0 ;
+ double *arg6 = (double *) 0 ;
+ double *arg7 = (double *) 0 ;
+ double *arg8 = (double *) 0 ;
+ double *arg9 = (double *) 0 ;
+ double *arg10 = (double *) 0 ;
+ double *arg11 = (double *) 0 ;
+ double *arg12 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ void *argp11 = 0 ;
+ int res11 = 0 ;
+ void *argp12 = 0 ;
+ int res12 = 0 ;
+ PyObject *swig_obj[12] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYlongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqParamLCC", 12, 12, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYlongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqParamLCC" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYlongname" "', argument " "2"" of type '" "char *""'");
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqParamLCC" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqParamLCC" "', argument " "3"" of type '" "double *""'");
}
- arg2 = (char *)(buf2);
- gridInqYlongname(arg1,arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqParamLCC" "', argument " "4"" of type '" "double *""'");
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gridInqParamLCC" "', argument " "5"" of type '" "double *""'");
+ }
+ arg5 = (double *)(argp5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gridInqParamLCC" "', argument " "6"" of type '" "double *""'");
+ }
+ arg6 = (double *)(argp6);
+ res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gridInqParamLCC" "', argument " "7"" of type '" "double *""'");
+ }
+ arg7 = (double *)(argp7);
+ res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gridInqParamLCC" "', argument " "8"" of type '" "double *""'");
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gridInqParamLCC" "', argument " "9"" of type '" "double *""'");
+ }
+ arg9 = (double *)(argp9);
+ res10 = SWIG_ConvertPtr(swig_obj[9], &argp10,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "gridInqParamLCC" "', argument " "10"" of type '" "double *""'");
+ }
+ arg10 = (double *)(argp10);
+ res11 = SWIG_ConvertPtr(swig_obj[10], &argp11,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "gridInqParamLCC" "', argument " "11"" of type '" "double *""'");
+ }
+ arg11 = (double *)(argp11);
+ res12 = SWIG_ConvertPtr(swig_obj[11], &argp12,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res12)) {
+ SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "gridInqParamLCC" "', argument " "12"" of type '" "double *""'");
+ }
+ arg12 = (double *)(argp12);
+ result = (int)gridInqParamLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYstdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefParamSTERE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double arg8 ;
+ double arg9 ;
+ double arg10 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ double val9 ;
+ int ecode9 = 0 ;
+ double val10 ;
+ int ecode10 = 0 ;
+ PyObject *swig_obj[10] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYstdname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefParamSTERE", 10, 10, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYstdname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefParamSTERE" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYstdname" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- gridInqYstdname(arg1,arg2);
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefParamSTERE" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefParamSTERE" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefParamSTERE" "', argument " "4"" of type '" "double""'");
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gridDefParamSTERE" "', argument " "5"" of type '" "double""'");
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gridDefParamSTERE" "', argument " "6"" of type '" "double""'");
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gridDefParamSTERE" "', argument " "7"" of type '" "double""'");
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gridDefParamSTERE" "', argument " "8"" of type '" "double""'");
+ }
+ arg8 = (double)(val8);
+ ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gridDefParamSTERE" "', argument " "9"" of type '" "double""'");
+ }
+ arg9 = (double)(val9);
+ ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gridDefParamSTERE" "', argument " "10"" of type '" "double""'");
+ }
+ arg10 = (double)(val10);
+ gridDefParamSTERE(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYunits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqParamSTERE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double arg2 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ double *arg5 = (double *) 0 ;
+ double *arg6 = (double *) 0 ;
+ double *arg7 = (double *) 0 ;
+ double *arg8 = (double *) 0 ;
+ double *arg9 = (double *) 0 ;
+ double *arg10 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ PyObject *swig_obj[10] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYunits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqParamSTERE", 10, 10, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYunits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqParamSTERE" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYunits" "', argument " "2"" of type '" "char *""'");
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqParamSTERE" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqParamSTERE" "', argument " "3"" of type '" "double *""'");
}
- arg2 = (char *)(buf2);
- gridInqYunits(arg1,arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqParamSTERE" "', argument " "4"" of type '" "double *""'");
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gridInqParamSTERE" "', argument " "5"" of type '" "double *""'");
+ }
+ arg5 = (double *)(argp5);
+ res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gridInqParamSTERE" "', argument " "6"" of type '" "double *""'");
+ }
+ arg6 = (double *)(argp6);
+ res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gridInqParamSTERE" "', argument " "7"" of type '" "double *""'");
+ }
+ arg7 = (double *)(argp7);
+ res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gridInqParamSTERE" "', argument " "8"" of type '" "double *""'");
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gridInqParamSTERE" "', argument " "9"" of type '" "double *""'");
+ }
+ arg9 = (double *)(argp9);
+ res10 = SWIG_ConvertPtr(swig_obj[9], &argp10,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "gridInqParamSTERE" "', argument " "10"" of type '" "double *""'");
+ }
+ arg10 = (double *)(argp10);
+ result = (int)gridInqParamSTERE(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefDatatype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefArea", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefDatatype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefArea" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefDatatype" "', argument " "2"" of type '" "int""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefArea" "', argument " "2"" of type '" "double const []""'");
}
- arg2 = (int)(val2);
- gridDefDatatype(arg1,arg2);
+ arg2 = (double *)(argp2);
+ gridDefArea(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8086,60 +13912,59 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqDatatype",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqArea", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqDatatype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqArea" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqDatatype(arg1);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqArea" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ gridInqArea(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridHasArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXval",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXval" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridHasArea" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqXval" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (double)gridInqXval(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ result = (int)gridHasArea(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefNvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -8147,162 +13972,177 @@ SWIGINTERN PyObject *_wrap_gridInqYval(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYval",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefNvertex", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYval" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefNvertex" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqYval" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefNvertex" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (double)gridInqYval(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_gridInqXinc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqXinc",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXinc" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- result = (double)gridInqXinc(arg1);
- resultobj = SWIG_From_double((double)(result));
+ gridDefNvertex(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYinc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqNvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double result;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqYinc",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYinc" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqNvertex" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double)gridInqYinc(arg1);
- resultobj = SWIG_From_double((double)(result));
+ result = (int)gridInqNvertex(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridIsCircular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefXbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridIsCircular",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefXbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridIsCircular" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridIsCircular(arg1);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXbounds" "', argument " "2"" of type '" "double const []""'");
+ }
+ arg2 = (double *)(argp2);
+ gridDefXbounds(arg1,(double const (*))arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridIsRotated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridIsRotated",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridIsRotated" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridIsRotated(arg1);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXbounds" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqXbounds(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqXpole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqXboundsPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double result;
+ int val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqXpole",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqXboundsPart", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXpole" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXboundsPart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double)gridInqXpole(arg1);
- resultobj = SWIG_From_double((double)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqXboundsPart" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridInqXboundsPart" "', argument " "3"" of type '" "size_t""'");
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqXboundsPart" "', argument " "4"" of type '" "double []""'");
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqXboundsPart(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefXpole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefYbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXpole",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefYbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXpole" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefXpole" "', argument " "2"" of type '" "double""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYbounds" "', argument " "2"" of type '" "double const []""'");
}
- arg2 = (double)(val2);
- gridDefXpole(arg1,arg2);
+ arg2 = (double *)(argp2);
+ gridDefYbounds(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8310,103 +14150,141 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqYpole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqYpole",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYpole" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double)gridInqYpole(arg1);
- resultobj = SWIG_From_double((double)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYbounds" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqYbounds(arg1,arg2);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefYpole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqYboundsPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
+ int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ size_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYpole",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqYboundsPart", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYpole" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYboundsPart" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefYpole" "', argument " "2"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridInqYboundsPart" "', argument " "2"" of type '" "int""'");
}
- arg2 = (double)(val2);
- gridDefYpole(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridInqYboundsPart" "', argument " "3"" of type '" "size_t""'");
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqYboundsPart" "', argument " "4"" of type '" "double []""'");
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqYboundsPart(arg1,arg2,arg3,arg4);
+ resultobj = SWIG_From_size_t((size_t)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefReducedPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
+ int *arg3 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double result;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqAngle",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefReducedPoints", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqAngle" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefReducedPoints" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double)gridInqAngle(arg1);
- resultobj = SWIG_From_double((double)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefReducedPoints" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridDefReducedPoints" "', argument " "3"" of type '" "int const []""'");
+ }
+ arg3 = (int *)(argp3);
+ gridDefReducedPoints(arg1,arg2,(int const (*))arg3);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqReducedPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
+ int *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefAngle",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridInqReducedPoints", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefAngle" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqReducedPoints" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefAngle" "', argument " "2"" of type '" "double""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqReducedPoints" "', argument " "2"" of type '" "int []""'");
}
- arg2 = (double)(val2);
- gridDefAngle(arg1,arg2);
+ arg2 = (int *)(argp2);
+ gridInqReducedPoints(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8414,7 +14292,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridChangeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -8422,21 +14300,20 @@ SWIGINTERN PyObject *_wrap_gridDefTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefTrunc",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridChangeType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefTrunc" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridChangeType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefTrunc" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridChangeType" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- gridDefTrunc(arg1,arg2);
+ gridChangeType(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8444,43 +14321,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqTrunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefComplexPacking(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqTrunc",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefComplexPacking", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqTrunc" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefComplexPacking" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqTrunc(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefComplexPacking" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ gridDefComplexPacking(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqGMEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqComplexPacking(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqGMEnd",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqGMEnd" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqComplexPacking" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqGMEnd(arg1);
+ result = (int)gridInqComplexPacking(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -8488,7 +14373,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefGMEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridDefScanningMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -8496,21 +14381,20 @@ SWIGINTERN PyObject *_wrap_gridDefGMEnd(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefGMEnd",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "gridDefScanningMode", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefGMEnd" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefScanningMode" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefGMEnd" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefScanningMode" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- gridDefGMEnd(arg1,arg2);
+ gridDefScanningMode(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8518,21 +14402,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqGMEni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gridInqScanningMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqGMEni",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqGMEni" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqScanningMode" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni(arg1);
+ result = (int)gridInqScanningMode(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -8540,59 +14425,62 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefGMEni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefGMEni",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisName", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefGMEni" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisName" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefGMEni" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- gridDefGMEni(arg1,arg2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisName" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ zaxisName(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqGMEni2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
+ char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqGMEni2",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqGMEni2" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisNamePtr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni2(arg1);
- resultobj = SWIG_From_int((int)(result));
+ result = (char *)zaxisNamePtr(arg1);
+ resultobj = SWIG_FromCharPtr((const char *)result);
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefGMEni2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -8600,21 +14488,43 @@ SWIGINTERN PyObject *_wrap_gridDefGMEni2(PyObject *SWIGUNUSEDPARM(self), PyObjec
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefGMEni2",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisCreate", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefGMEni2" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisCreate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefGMEni2" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisCreate" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- gridDefGMEni2(arg1,arg2);
+ result = (int)zaxisCreate(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_zaxisDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDestroy" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ zaxisDestroy(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8622,21 +14532,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqGMEni3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqGMEni3",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqGMEni3" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni3(arg1);
+ result = (int)zaxisInqType(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -8644,233 +14555,74 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefGMEni3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefGMEni3",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefGMEni3" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqSize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefGMEni3" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- gridDefGMEni3(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)zaxisInqSize(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefLCC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
- double arg5 ;
- double arg6 ;
- double arg7 ;
- double arg8 ;
- int arg9 ;
- int arg10 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
- double val5 ;
- int ecode5 = 0 ;
- double val6 ;
- int ecode6 = 0 ;
- double val7 ;
- int ecode7 = 0 ;
- double val8 ;
- int ecode8 = 0 ;
- int val9 ;
- int ecode9 = 0 ;
- int val10 ;
- int ecode10 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
- PyObject * obj6 = 0 ;
- PyObject * obj7 = 0 ;
- PyObject * obj8 = 0 ;
- PyObject * obj9 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:gridDefLCC",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefLCC" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDuplicate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefLCC" "', argument " "2"" of type '" "double""'");
- }
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefLCC" "', argument " "3"" of type '" "double""'");
- }
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefLCC" "', argument " "4"" of type '" "double""'");
- }
- arg4 = (double)(val4);
- ecode5 = SWIG_AsVal_double(obj4, &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gridDefLCC" "', argument " "5"" of type '" "double""'");
- }
- arg5 = (double)(val5);
- ecode6 = SWIG_AsVal_double(obj5, &val6);
- if (!SWIG_IsOK(ecode6)) {
- SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gridDefLCC" "', argument " "6"" of type '" "double""'");
- }
- arg6 = (double)(val6);
- ecode7 = SWIG_AsVal_double(obj6, &val7);
- if (!SWIG_IsOK(ecode7)) {
- SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gridDefLCC" "', argument " "7"" of type '" "double""'");
- }
- arg7 = (double)(val7);
- ecode8 = SWIG_AsVal_double(obj7, &val8);
- if (!SWIG_IsOK(ecode8)) {
- SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gridDefLCC" "', argument " "8"" of type '" "double""'");
- }
- arg8 = (double)(val8);
- ecode9 = SWIG_AsVal_int(obj8, &val9);
- if (!SWIG_IsOK(ecode9)) {
- SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gridDefLCC" "', argument " "9"" of type '" "int""'");
- }
- arg9 = (int)(val9);
- ecode10 = SWIG_AsVal_int(obj9, &val10);
- if (!SWIG_IsOK(ecode10)) {
- SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gridDefLCC" "', argument " "10"" of type '" "int""'");
- }
- arg10 = (int)(val10);
- gridDefLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
- resultobj = SWIG_Py_Void();
+ result = (int)zaxisDuplicate(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqLCC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLevels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
- double *arg5 = (double *) 0 ;
- double *arg6 = (double *) 0 ;
- double *arg7 = (double *) 0 ;
- double *arg8 = (double *) 0 ;
- int *arg9 = (int *) 0 ;
- int *arg10 = (int *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- void *argp7 = 0 ;
- int res7 = 0 ;
- void *argp8 = 0 ;
- int res8 = 0 ;
- void *argp9 = 0 ;
- int res9 = 0 ;
- void *argp10 = 0 ;
- int res10 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
- PyObject * obj6 = 0 ;
- PyObject * obj7 = 0 ;
- PyObject * obj8 = 0 ;
- PyObject * obj9 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:gridInqLCC",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLevels", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqLCC" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLevels" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqLCC" "', argument " "2"" of type '" "double *""'");
- }
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLevels" "', argument " "2"" of type '" "double const []""'");
+ }
arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqLCC" "', argument " "3"" of type '" "double *""'");
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqLCC" "', argument " "4"" of type '" "double *""'");
- }
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gridInqLCC" "', argument " "5"" of type '" "double *""'");
- }
- arg5 = (double *)(argp5);
- res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gridInqLCC" "', argument " "6"" of type '" "double *""'");
- }
- arg6 = (double *)(argp6);
- res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res7)) {
- SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gridInqLCC" "', argument " "7"" of type '" "double *""'");
- }
- arg7 = (double *)(argp7);
- res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res8)) {
- SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "gridInqLCC" "', argument " "8"" of type '" "double *""'");
- }
- arg8 = (double *)(argp8);
- res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res9)) {
- SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gridInqLCC" "', argument " "9"" of type '" "int *""'");
- }
- arg9 = (int *)(argp9);
- res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res10)) {
- SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "gridInqLCC" "', argument " "10"" of type '" "int *""'");
- }
- arg10 = (int *)(argp10);
- gridInqLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ zaxisDefLevels(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8878,65 +14630,36 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefLcc2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefCvals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
- double arg5 ;
- double arg6 ;
+ char **arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
- double val5 ;
- int ecode5 = 0 ;
- double val6 ;
- int ecode6 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gridDefLcc2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefCvals", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefLcc2" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefCvals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefLcc2" "', argument " "2"" of type '" "double""'");
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefCvals" "', argument " "2"" of type '" "char const *[]""'");
}
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
+ arg2 = (char **)(argp2);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefLcc2" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zaxisDefCvals" "', argument " "3"" of type '" "int""'");
}
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefLcc2" "', argument " "4"" of type '" "double""'");
- }
- arg4 = (double)(val4);
- ecode5 = SWIG_AsVal_double(obj4, &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gridDefLcc2" "', argument " "5"" of type '" "double""'");
- }
- arg5 = (double)(val5);
- ecode6 = SWIG_AsVal_double(obj5, &val6);
- if (!SWIG_IsOK(ecode6)) {
- SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gridDefLcc2" "', argument " "6"" of type '" "double""'");
- }
- arg6 = (double)(val6);
- gridDefLcc2(arg1,arg2,arg3,arg4,arg5,arg6);
+ arg3 = (int)(val3);
+ zaxisDefCvals(arg1,(char const *(*))arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -8944,191 +14667,119 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqLcc2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLevels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
- double *arg5 = (double *) 0 ;
- double *arg6 = (double *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
- PyObject * obj5 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gridInqLcc2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqLevels", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqLcc2" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLevels" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqLcc2" "', argument " "2"" of type '" "double *""'");
- }
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLevels" "', argument " "2"" of type '" "double []""'");
+ }
arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqLcc2" "', argument " "3"" of type '" "double *""'");
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqLcc2" "', argument " "4"" of type '" "double *""'");
- }
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gridInqLcc2" "', argument " "5"" of type '" "double *""'");
- }
- arg5 = (double *)(argp5);
- res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gridInqLcc2" "', argument " "6"" of type '" "double *""'");
- }
- arg6 = (double *)(argp6);
- gridInqLcc2(arg1,arg2,arg3,arg4,arg5,arg6);
- resultobj = SWIG_Py_Void();
+ result = (int)zaxisInqLevels(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefLaea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqCLen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:gridDefLaea",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefLaea" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqCLen" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefLaea" "', argument " "2"" of type '" "double""'");
- }
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gridDefLaea" "', argument " "3"" of type '" "double""'");
- }
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(obj3, &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gridDefLaea" "', argument " "4"" of type '" "double""'");
- }
- arg4 = (double)(val4);
- gridDefLaea(arg1,arg2,arg3,arg4);
- resultobj = SWIG_Py_Void();
+ result = (int)zaxisInqCLen(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqLaea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqCVals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
+ char ***arg2 = (char ***) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:gridInqLaea",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqCVals", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqLaea" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqCVals" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_p_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqLaea" "', argument " "2"" of type '" "double *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqCVals" "', argument " "2"" of type '" "char ***""'");
}
- arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridInqLaea" "', argument " "3"" of type '" "double *""'");
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gridInqLaea" "', argument " "4"" of type '" "double *""'");
- }
- arg4 = (double *)(argp4);
- gridInqLaea(arg1,arg2,arg3,arg4);
- resultobj = SWIG_Py_Void();
+ arg2 = (char ***)(argp2);
+ result = (int)zaxisInqCVals(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
+ double arg3 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefArea",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLevel", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefArea" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLevel" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefArea" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- gridDefArea(arg1,(double const *)arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zaxisDefLevel" "', argument " "3"" of type '" "double""'");
+ }
+ arg3 = (double)(val3);
+ zaxisDefLevel(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9136,29 +14787,58 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqArea",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqLevel", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqArea" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLevel" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqArea" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- gridInqArea(arg1,arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqLevel" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (double)zaxisInqLevel(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_zaxisDefNlevRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefNlevRef", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefNlevRef" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefNlevRef" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ zaxisDefNlevRef(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9166,21 +14846,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridHasArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqNlevRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridHasArea",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridHasArea" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqNlevRef" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridHasArea(arg1);
+ result = (int)zaxisInqNlevRef(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -9188,7 +14869,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefNvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -9196,21 +14877,20 @@ SWIGINTERN PyObject *_wrap_gridDefNvertex(PyObject *SWIGUNUSEDPARM(self), PyObje
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefNvertex",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefNumber", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefNvertex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefNumber" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefNvertex" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefNumber" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- gridDefNvertex(arg1,arg2);
+ zaxisDefNumber(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9218,21 +14898,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqNvertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:gridInqNvertex",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqNvertex" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqNumber" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)gridInqNvertex(arg1);
+ result = (int)zaxisInqNumber(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -9240,29 +14921,28 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridDefXbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefUUID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefXbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefUUID", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefXbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefUUID" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefXbounds" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- gridDefXbounds(arg1,(double const *)arg2);
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefUUID" "', argument " "2"" of type '" "unsigned char const [16]""'");
+ }
+ arg2 = (unsigned char *)(argp2);
+ zaxisDefUUID(arg1,(unsigned char const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9270,198 +14950,228 @@ fail:
}
-SWIGINTERN PyObject *_wrap_gridInqXbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqUUID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqXbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqUUID", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqXbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUUID" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqUUID" "', argument " "2"" of type '" "unsigned char [16]""'");
+ }
+ arg2 = (unsigned char *)(argp2);
+ zaxisInqUUID(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_zaxisDefName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefName", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefName" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqXbounds" "', argument " "2"" of type '" "double *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefName" "', argument " "2"" of type '" "char const *""'");
}
- arg2 = (double *)(argp2);
- result = (int)gridInqXbounds(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (char *)(buf2);
+ zaxisDefName(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefYbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridDefYbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqName", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefYbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqName" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridDefYbounds" "', argument " "2"" of type '" "double const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqName" "', argument " "2"" of type '" "char *""'");
}
- arg2 = (double *)(argp2);
- gridDefYbounds(arg1,(double const *)arg2);
+ arg2 = (char *)(buf2);
+ zaxisInqName(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqYbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqYbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqYbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqYbounds" "', argument " "2"" of type '" "double *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLongname" "', argument " "2"" of type '" "char const *""'");
}
- arg2 = (double *)(argp2);
- result = (int)gridInqYbounds(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ arg2 = (char *)(buf2);
+ zaxisDefLongname(arg1,(char const *)arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridDefRowlon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int *arg3 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:gridDefRowlon",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqLongname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridDefRowlon" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLongname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridDefRowlon" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gridDefRowlon" "', argument " "3"" of type '" "int const *""'");
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLongname" "', argument " "2"" of type '" "char *""'");
}
- arg3 = (int *)(argp3);
- gridDefRowlon(arg1,arg2,(int const *)arg3);
+ arg2 = (char *)(buf2);
+ zaxisInqLongname(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridInqRowlon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int *arg2 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridInqRowlon",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefUnits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridInqRowlon" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefUnits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gridInqRowlon" "', argument " "2"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefUnits" "', argument " "2"" of type '" "char const *""'");
}
- arg2 = (int *)(argp2);
- gridInqRowlon(arg1,arg2);
+ arg2 = (char *)(buf2);
+ zaxisDefUnits(arg1,(char const *)arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_gridChangeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:gridChangeType",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqUnits", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gridChangeType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUnits" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gridChangeType" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- gridChangeType(arg1,arg2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqUnits" "', argument " "2"" of type '" "char *""'");
+ }
+ arg2 = (char *)(buf2);
+ zaxisInqUnits(arg1,arg2);
resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqStdname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
@@ -9470,21 +15180,20 @@ SWIGINTERN PyObject *_wrap_zaxisName(PyObject *SWIGUNUSEDPARM(self), PyObject *a
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisName",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqStdname", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqStdname" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisName" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqStdname" "', argument " "2"" of type '" "char *""'");
}
arg2 = (char *)(buf2);
- zaxisName(arg1,arg2);
+ zaxisInqStdname(arg1,arg2);
resultobj = SWIG_Py_Void();
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
@@ -9494,7 +15203,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -9502,43 +15211,20 @@ SWIGINTERN PyObject *_wrap_zaxisCreate(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisCreate",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefDatatype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisCreate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefDatatype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisCreate" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefDatatype" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (int)zaxisCreate(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_zaxisDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisDestroy",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDestroy" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- zaxisDestroy(arg1);
+ zaxisDefDatatype(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9546,21 +15232,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqType",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqDatatype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisInqType(arg1);
+ result = (int)zaxisInqDatatype(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -9568,43 +15255,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqSize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefPositive", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqSize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefPositive" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisInqSize(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefPositive" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ zaxisDefPositive(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisDuplicate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDuplicate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqPositive" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisDuplicate(arg1);
+ result = (int)zaxisInqPositive(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -9612,29 +15307,21 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisResize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisResize",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisResize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefScalar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisResize" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- zaxisResize(arg1,arg2);
+ zaxisDefScalar(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9642,33 +15329,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisPrint",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisPrint" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqScalar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- zaxisPrint(arg1);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_zaxisSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)":zaxisSize")) SWIG_fail;
- result = (int)zaxisSize();
+ result = (int)zaxisInqScalar(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -9676,29 +15352,28 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisDefLevels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefLevels",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLtype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLevels" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLtype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLevels" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- zaxisDefLevels(arg1,(double const *)arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefLtype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ zaxisDefLtype(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9706,68 +15381,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqLevels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqLevels",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLevels" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLtype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLevels" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- zaxisInqLevels(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)zaxisInqLtype(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLtype2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- double arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:zaxisDefLevel",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLtype2", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLtype2" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefLevel" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefLtype2" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "zaxisDefLevel" "', argument " "3"" of type '" "double""'");
- }
- arg3 = (double)(val3);
- zaxisDefLevel(arg1,arg2,arg3);
+ zaxisDefLtype2(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -9775,236 +15433,201 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLtype2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqLevel",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLevel" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLtype2" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqLevel" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (double)zaxisInqLevel(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ result = (int)zaxisInqLtype2(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefVct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ double *arg3 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefName",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefVct", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefVct" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefName" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- zaxisDefName(arg1,(char const *)arg2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefVct" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zaxisDefVct" "', argument " "3"" of type '" "double const []""'");
+ }
+ arg3 = (double *)(argp3);
+ zaxisDefVct(arg1,arg2,(double const (*))arg3);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqVct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefLongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqVct", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLongname" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLongname" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- zaxisDefLongname(arg1,(char const *)arg2);
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqVct" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqVct" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ zaxisInqVct(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqVctSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefUnits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefUnits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqVctSize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefUnits" "', argument " "2"" of type '" "char const *""'");
- }
- arg2 = (char *)(buf2);
- zaxisDefUnits(arg1,(char const *)arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ result = (int)zaxisInqVctSize(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqVctPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ double *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqName",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqVctPtr" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqName" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- zaxisInqName(arg1,arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ result = (double *)zaxisInqVctPtr(arg1);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefLbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqLongname",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefLbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLongname" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- zaxisInqLongname(arg1,arg2);
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLbounds" "', argument " "2"" of type '" "double const []""'");
+ }
+ arg2 = (double *)(argp2);
+ zaxisDefLbounds(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqUnits",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqLbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUnits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqUnits" "', argument " "2"" of type '" "char *""'");
- }
- arg2 = (char *)(buf2);
- zaxisInqUnits(arg1,arg2);
- resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLbounds" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqLbounds(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqLbound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -10012,21 +15635,50 @@ SWIGINTERN PyObject *_wrap_zaxisDefDatatype(PyObject *SWIGUNUSEDPARM(self), PyOb
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefDatatype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqLbound", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefDatatype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLbound" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefDatatype" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqLbound" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- zaxisDefDatatype(arg1,arg2);
+ result = (double)zaxisInqLbound(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_zaxisDefUbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ double *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefUbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefUbounds" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefUbounds" "', argument " "2"" of type '" "double const []""'");
+ }
+ arg2 = (double *)(argp2);
+ zaxisDefUbounds(arg1,(double const (*))arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10034,21 +15686,29 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqDatatype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqUbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqDatatype",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqUbounds", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqDatatype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUbounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisInqDatatype(arg1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqUbounds" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqUbounds(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -10056,7 +15716,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisDefLtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqUbound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -10064,104 +15724,109 @@ SWIGINTERN PyObject *_wrap_zaxisDefLtype(PyObject *SWIGUNUSEDPARM(self), PyObjec
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefLtype",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqUbound", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLtype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUbound" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefLtype" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqUbound" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- zaxisDefLtype(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (double)zaxisInqUbound(arg1,arg2);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqLtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisDefWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqLtype",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisDefWeights", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLtype" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefWeights" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisInqLtype(arg1);
- resultobj = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefWeights" "', argument " "2"" of type '" "double const []""'");
+ }
+ arg2 = (double *)(argp2);
+ zaxisDefWeights(arg1,(double const (*))arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqLevelsPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisInqWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqLevelsPtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisInqWeights", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLevelsPtr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqWeights" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double *)zaxisInqLevelsPtr(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqWeights" "', argument " "2"" of type '" "double []""'");
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqWeights(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefVct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_zaxisChangeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- double *arg3 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:zaxisDefVct",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "zaxisChangeType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefVct" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisChangeType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisDefVct" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisChangeType" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zaxisDefVct" "', argument " "3"" of type '" "double const *""'");
- }
- arg3 = (double *)(argp3);
- zaxisDefVct(arg1,arg2,(double const *)arg3);
+ zaxisChangeType(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10169,21 +15834,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqVctSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqVctSize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqVctSize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisCreate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)zaxisInqVctSize(arg1);
+ result = (int)taxisCreate(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -10191,52 +15857,44 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqVctPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- double *result = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:zaxisInqVctPtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqVctPtr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDestroy" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (double *)zaxisInqVctPtr(arg1);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ taxisDestroy(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqLbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqLbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDuplicate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqLbounds" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- result = (int)zaxisInqLbounds(arg1,arg2);
+ result = (int)taxisDuplicate(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -10244,61 +15902,80 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqUbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisCopyTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqUbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisCopyTimestep", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisCopyTimestep" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqUbounds" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- result = (int)zaxisInqUbounds(arg1,arg2);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisCopyTimestep" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ taxisCopyTimestep(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefType", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefType" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefType" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ taxisDefType(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_taxisInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqWeights",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqWeights" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqType" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisInqWeights" "', argument " "2"" of type '" "double *""'");
- }
- arg2 = (double *)(argp2);
- result = (int)zaxisInqWeights(arg1,arg2);
+ result = (int)taxisInqType(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -10306,38 +15983,42 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisInqLbound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefVdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ void *argp2 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqLbound",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefVdate", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqLbound" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqLbound" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (double)zaxisInqLbound(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisDefVdate" "', argument " "2"" of type '" "int64_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "taxisDefVdate" "', argument " "2"" of type '" "int64_t""'");
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ taxisDefVdate(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisInqUbound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefVtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -10345,112 +16026,101 @@ SWIGINTERN PyObject *_wrap_zaxisInqUbound(PyObject *SWIGUNUSEDPARM(self), PyObje
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- double result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisInqUbound",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefVtime", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisInqUbound" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisInqUbound" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefVtime" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (double)zaxisInqUbound(arg1,arg2);
- resultobj = SWIG_From_double((double)(result));
+ taxisDefVtime(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefLbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqVdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int64_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefLbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefLbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefLbounds" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- zaxisDefLbounds(arg1,(double const *)arg2);
- resultobj = SWIG_Py_Void();
+ result = taxisInqVdate(arg1);
+ resultobj = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefUbounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqVtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefUbounds",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefUbounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefUbounds" "', argument " "2"" of type '" "double const *""'");
- }
- arg2 = (double *)(argp2);
- zaxisDefUbounds(arg1,(double const *)arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)taxisInqVtime(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_zaxisDefWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefRdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
+ void *argp2 ;
int res2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisDefWeights",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefRdate", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisDefWeights" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefRdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zaxisDefWeights" "', argument " "2"" of type '" "double const *""'");
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisDefRdate" "', argument " "2"" of type '" "int64_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "taxisDefRdate" "', argument " "2"" of type '" "int64_t""'");
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
}
- arg2 = (double *)(argp2);
- zaxisDefWeights(arg1,(double const *)arg2);
+ taxisDefRdate(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10458,7 +16128,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_zaxisChangeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefRtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -10466,21 +16136,20 @@ SWIGINTERN PyObject *_wrap_zaxisChangeType(PyObject *SWIGUNUSEDPARM(self), PyObj
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:zaxisChangeType",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefRtime", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "zaxisChangeType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefRtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zaxisChangeType" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefRtime" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- zaxisChangeType(arg1,arg2);
+ taxisDefRtime(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10488,64 +16157,45 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
-
- if (!PyArg_ParseTuple(args,(char *)"O:taxisCreate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisCreate" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- result = (int)taxisCreate(arg1);
- resultobj = SWIG_From_int((int)(result));
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_taxisDestroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqRdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
+ int64_t result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisDestroy",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDestroy" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqRdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- taxisDestroy(arg1);
- resultobj = SWIG_Py_Void();
+ result = taxisInqRdate(arg1);
+ resultobj = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisDuplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqRtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisDuplicate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDuplicate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqRtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisDuplicate(arg1);
+ result = (int)taxisInqRtime(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -10553,29 +16203,34 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisCopyTimestep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefFdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisCopyTimestep",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefFdate", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisCopyTimestep" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefFdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisCopyTimestep" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisCopyTimestep(arg1,arg2);
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisDefFdate" "', argument " "2"" of type '" "int64_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "taxisDefFdate" "', argument " "2"" of type '" "int64_t""'");
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ taxisDefFdate(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10583,7 +16238,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisDefType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefFtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
@@ -10591,21 +16246,20 @@ SWIGINTERN PyObject *_wrap_taxisDefType(PyObject *SWIGUNUSEDPARM(self), PyObject
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefType",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefFtime", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefFtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefType" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefFtime" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- taxisDefType(arg1,arg2);
+ taxisDefFtime(arg1,arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10613,119 +16267,90 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisDefVdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqFdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int64_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefVdate",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVdate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqFdate" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefVdate" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefVdate(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = taxisInqFdate(arg1);
+ resultobj = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisDefVtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqFtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefVtime",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVtime" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqFtime" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefVtime" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefVtime(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)taxisInqFtime(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisDefRdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisHasBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefRdate",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefRdate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisHasBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefRdate" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefRdate(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)taxisHasBounds(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisDefRtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisWithBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefRtime",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefRtime" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisWithBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefRtime" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefRtime(arg1,arg2);
+ taxisWithBounds(arg1);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -10733,22 +16358,22 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisHasBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDeleteBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisHasBounds",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisHasBounds" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDeleteBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisHasBounds(arg1);
- resultobj = SWIG_From_int((int)(result));
+ taxisDeleteBounds(arg1);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
@@ -10758,34 +16383,44 @@ fail:
SWIGINTERN PyObject *_wrap_taxisDefVdateBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- int arg3 ;
+ int64_t arg2 ;
+ int64_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:taxisDefVdateBounds",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefVdateBounds", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVdateBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefVdateBounds" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "taxisDefVdateBounds" "', argument " "3"" of type '" "int""'");
- }
- arg3 = (int)(val3);
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisDefVdateBounds" "', argument " "2"" of type '" "int64_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "taxisDefVdateBounds" "', argument " "2"" of type '" "int64_t""'");
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ {
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "taxisDefVdateBounds" "', argument " "3"" of type '" "int64_t""'");
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "taxisDefVdateBounds" "', argument " "3"" of type '" "int64_t""'");
+ } else {
+ arg3 = *((int64_t *)(argp3));
+ }
+ }
taxisDefVdateBounds(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
@@ -10805,22 +16440,20 @@ SWIGINTERN PyObject *_wrap_taxisDefVtimeBounds(PyObject *SWIGUNUSEDPARM(self), P
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:taxisDefVtimeBounds",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefVtimeBounds", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefVtimeBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefVtimeBounds" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(obj2, &val3);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "taxisDefVtimeBounds" "', argument " "3"" of type '" "int""'");
}
@@ -10836,34 +16469,32 @@ fail:
SWIGINTERN PyObject *_wrap_taxisInqVdateBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int *arg2 = (int *) 0 ;
- int *arg3 = (int *) 0 ;
+ int64_t *arg2 = (int64_t *) 0 ;
+ int64_t *arg3 = (int64_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:taxisInqVdateBounds",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisInqVdateBounds", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVdateBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int64_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisInqVdateBounds" "', argument " "2"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisInqVdateBounds" "', argument " "2"" of type '" "int64_t *""'");
}
- arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
+ arg2 = (int64_t *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int64_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "taxisInqVdateBounds" "', argument " "3"" of type '" "int *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "taxisInqVdateBounds" "', argument " "3"" of type '" "int64_t *""'");
}
- arg3 = (int *)(argp3);
+ arg3 = (int64_t *)(argp3);
taxisInqVdateBounds(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
return resultobj;
@@ -10883,22 +16514,20 @@ SWIGINTERN PyObject *_wrap_taxisInqVtimeBounds(PyObject *SWIGUNUSEDPARM(self), P
int res2 = 0 ;
void *argp3 = 0 ;
int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:taxisInqVtimeBounds",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisInqVtimeBounds", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVtimeBounds" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taxisInqVtimeBounds" "', argument " "2"" of type '" "int *""'");
}
arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "taxisInqVtimeBounds" "', argument " "3"" of type '" "int *""'");
}
@@ -10919,16 +16548,15 @@ SWIGINTERN PyObject *_wrap_taxisDefCalendar(PyObject *SWIGUNUSEDPARM(self), PyOb
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefCalendar",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefCalendar", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefCalendar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefCalendar" "', argument " "2"" of type '" "int""'");
}
@@ -10941,103 +16569,74 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisDefTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqCalendar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefTunit",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefTunit" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqCalendar" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefTunit" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefTunit(arg1,arg2);
- resultobj = SWIG_Py_Void();
+ result = (int)taxisInqCalendar(arg1);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisDefNumavg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OO:taxisDefNumavg",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefNumavg" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefNumavg" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- taxisDefNumavg(arg1,arg2);
- resultobj = SWIG_Py_Void();
- return resultobj;
-fail:
- return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_taxisInqType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqType",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefTunit", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqType" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefTunit" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqType(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefTunit" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ taxisDefTunit(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisInqVdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqVdate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVdate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqTunit" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqVdate(arg1);
+ result = (int)taxisInqTunit(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -11045,43 +16644,51 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisInqVtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefForecastTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqVtime",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefForecastTunit", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqVtime" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefForecastTunit" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqVtime(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefForecastTunit" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ taxisDefForecastTunit(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisInqRdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqForecastTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqRdate",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqRdate" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqForecastTunit" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqRdate(arg1);
+ result = (int)taxisInqForecastTunit(arg1);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -11089,66 +16696,81 @@ fail:
}
-SWIGINTERN PyObject *_wrap_taxisInqRtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefForecastPeriod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ double arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ double val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqRtime",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefForecastPeriod", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqRtime" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefForecastPeriod" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqRtime(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefForecastPeriod" "', argument " "2"" of type '" "double""'");
+ }
+ arg2 = (double)(val2);
+ taxisDefForecastPeriod(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisInqCalendar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisInqForecastPeriod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ PyObject *swig_obj[1] ;
+ double result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqCalendar",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqCalendar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqForecastPeriod" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqCalendar(arg1);
- resultobj = SWIG_From_int((int)(result));
+ result = (double)taxisInqForecastPeriod(arg1);
+ resultobj = SWIG_From_double((double)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_taxisInqTunit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_taxisDefNumavg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
- int result;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqTunit",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "taxisDefNumavg", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqTunit" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisDefNumavg" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)taxisInqTunit(arg1);
- resultobj = SWIG_From_int((int)(result));
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "taxisDefNumavg" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ taxisDefNumavg(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
@@ -11160,11 +16782,12 @@ SWIGINTERN PyObject *_wrap_taxisInqNumavg(PyObject *SWIGUNUSEDPARM(self), PyObje
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:taxisInqNumavg",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "taxisInqNumavg" "', argument " "1"" of type '" "int""'");
}
@@ -11182,11 +16805,12 @@ SWIGINTERN PyObject *_wrap_tunitNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:tunitNamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tunitNamePtr" "', argument " "1"" of type '" "int""'");
}
@@ -11215,29 +16839,26 @@ SWIGINTERN PyObject *_wrap_institutDef(PyObject *SWIGUNUSEDPARM(self), PyObject
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:institutDef",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "institutDef", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutDef" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "institutDef" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "institutDef" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "institutDef" "', argument " "4"" of type '" "char const *""'");
}
@@ -11270,29 +16891,26 @@ SWIGINTERN PyObject *_wrap_institutInq(PyObject *SWIGUNUSEDPARM(self), PyObject
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
+ PyObject *swig_obj[4] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOOO:institutInq",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "institutInq", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutInq" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "institutInq" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "institutInq" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "institutInq" "', argument " "4"" of type '" "char const *""'");
}
@@ -11313,7 +16931,7 @@ SWIGINTERN PyObject *_wrap_institutInqNumber(PyObject *SWIGUNUSEDPARM(self), PyO
PyObject *resultobj = 0;
int result;
- if (!PyArg_ParseTuple(args,(char *)":institutInqNumber")) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "institutInqNumber", 0, 0, 0)) SWIG_fail;
result = (int)institutInqNumber();
resultobj = SWIG_From_int((int)(result));
return resultobj;
@@ -11327,11 +16945,12 @@ SWIGINTERN PyObject *_wrap_institutInqCenter(PyObject *SWIGUNUSEDPARM(self), PyO
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:institutInqCenter",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutInqCenter" "', argument " "1"" of type '" "int""'");
}
@@ -11349,11 +16968,12 @@ SWIGINTERN PyObject *_wrap_institutInqSubcenter(PyObject *SWIGUNUSEDPARM(self),
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:institutInqSubcenter",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutInqSubcenter" "', argument " "1"" of type '" "int""'");
}
@@ -11371,11 +16991,12 @@ SWIGINTERN PyObject *_wrap_institutInqNamePtr(PyObject *SWIGUNUSEDPARM(self), Py
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:institutInqNamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutInqNamePtr" "', argument " "1"" of type '" "int""'");
}
@@ -11393,11 +17014,12 @@ SWIGINTERN PyObject *_wrap_institutInqLongnamePtr(PyObject *SWIGUNUSEDPARM(self)
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:institutInqLongnamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "institutInqLongnamePtr" "', argument " "1"" of type '" "int""'");
}
@@ -11422,23 +17044,21 @@ SWIGINTERN PyObject *_wrap_modelDef(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:modelDef",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "modelDef", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "modelDef" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "modelDef" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "modelDef" "', argument " "3"" of type '" "char const *""'");
}
@@ -11465,28 +17085,26 @@ SWIGINTERN PyObject *_wrap_modelInq(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:modelInq",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "modelInq", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "modelInq" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "modelInq" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "modelInq" "', argument " "3"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "modelInq" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
- result = (int)modelInq(arg1,arg2,arg3);
+ result = (int)modelInq(arg1,arg2,(char const *)arg3);
resultobj = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
@@ -11501,11 +17119,12 @@ SWIGINTERN PyObject *_wrap_modelInqInstitut(PyObject *SWIGUNUSEDPARM(self), PyOb
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:modelInqInstitut",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "modelInqInstitut" "', argument " "1"" of type '" "int""'");
}
@@ -11523,11 +17142,12 @@ SWIGINTERN PyObject *_wrap_modelInqGribID(PyObject *SWIGUNUSEDPARM(self), PyObje
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:modelInqGribID",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "modelInqGribID" "', argument " "1"" of type '" "int""'");
}
@@ -11545,11 +17165,12 @@ SWIGINTERN PyObject *_wrap_modelInqNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObj
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:modelInqNamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "modelInqNamePtr" "', argument " "1"" of type '" "int""'");
}
@@ -11562,35 +17183,31 @@ fail:
}
-SWIGINTERN PyObject *_wrap_tableWriteC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_tableFWriteC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- char *arg1 = (char *) 0 ;
+ FILE *arg1 = (FILE *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:tableWriteC",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!SWIG_Python_UnpackTuple(args, "tableFWriteC", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tableWriteC" "', argument " "1"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tableFWriteC" "', argument " "1"" of type '" "FILE *""'");
}
- arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ arg1 = (FILE *)(argp1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableWriteC" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableFWriteC" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- tableWriteC((char const *)arg1,arg2);
+ tableFWriteC(arg1,arg2);
resultobj = SWIG_Py_Void();
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return resultobj;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return NULL;
}
@@ -11604,16 +17221,15 @@ SWIGINTERN PyObject *_wrap_tableWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *
int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:tableWrite",&obj0,&obj1)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!SWIG_Python_UnpackTuple(args, "tableWrite", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tableWrite" "', argument " "1"" of type '" "char const *""'");
}
arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableWrite" "', argument " "2"" of type '" "int""'");
}
@@ -11634,11 +17250,12 @@ SWIGINTERN PyObject *_wrap_tableRead(PyObject *SWIGUNUSEDPARM(self), PyObject *a
int res1 ;
char *buf1 = 0 ;
int alloc1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:tableRead",&obj0)) SWIG_fail;
- res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tableRead" "', argument " "1"" of type '" "char const *""'");
}
@@ -11665,23 +17282,21 @@ SWIGINTERN PyObject *_wrap_tableDef(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableDef",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "tableDef", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableDef" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableDef" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableDef" "', argument " "3"" of type '" "char const *""'");
}
@@ -11701,11 +17316,12 @@ SWIGINTERN PyObject *_wrap_tableInqNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObj
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
char *result = 0 ;
- if (!PyArg_ParseTuple(args,(char *)"O:tableInqNamePtr",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqNamePtr" "', argument " "1"" of type '" "int""'");
}
@@ -11718,72 +17334,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_tableDefEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
- PyObject *resultobj = 0;
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- char *arg4 = (char *) 0 ;
- char *arg5 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int res4 ;
- char *buf4 = 0 ;
- int alloc4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
-
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:tableDefEntry",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableDefEntry" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableDefEntry" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableDefEntry" "', argument " "3"" of type '" "char const *""'");
- }
- arg3 = (char *)(buf3);
- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tableDefEntry" "', argument " "4"" of type '" "char const *""'");
- }
- arg4 = (char *)(buf4);
- res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "tableDefEntry" "', argument " "5"" of type '" "char const *""'");
- }
- arg5 = (char *)(buf5);
- tableDefEntry(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
- resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
- return resultobj;
-fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
- return NULL;
-}
-
-
SWIGINTERN PyObject *_wrap_tableInq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
@@ -11796,23 +17346,21 @@ SWIGINTERN PyObject *_wrap_tableInq(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[3] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableInq",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "tableInq", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInq" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInq" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInq" "', argument " "3"" of type '" "char const *""'");
}
@@ -11831,7 +17379,7 @@ SWIGINTERN PyObject *_wrap_tableInqNumber(PyObject *SWIGUNUSEDPARM(self), PyObje
PyObject *resultobj = 0;
int result;
- if (!PyArg_ParseTuple(args,(char *)":tableInqNumber")) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "tableInqNumber", 0, 0, 0)) SWIG_fail;
result = (int)tableInqNumber();
resultobj = SWIG_From_int((int)(result));
return resultobj;
@@ -11845,11 +17393,12 @@ SWIGINTERN PyObject *_wrap_tableInqNum(PyObject *SWIGUNUSEDPARM(self), PyObject
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:tableInqNum",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqNum" "', argument " "1"" of type '" "int""'");
}
@@ -11867,11 +17416,12 @@ SWIGINTERN PyObject *_wrap_tableInqModel(PyObject *SWIGUNUSEDPARM(self), PyObjec
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:tableInqModel",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqModel" "', argument " "1"" of type '" "int""'");
}
@@ -11884,342 +17434,476 @@ fail:
}
-SWIGINTERN PyObject *_wrap_tableInqPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_tableInqEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
+ int arg3 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
+ char *arg6 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int res5 ;
char *buf5 = 0 ;
int alloc5 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- PyObject * obj3 = 0 ;
- PyObject * obj4 = 0 ;
+ int res6 ;
+ char *buf6 = 0 ;
+ int alloc6 = 0 ;
+ PyObject *swig_obj[6] ;
- if (!PyArg_ParseTuple(args,(char *)"OOOOO:tableInqPar",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "tableInqEntry", 6, 6, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqPar" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqEntry" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqPar" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqEntry" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInqPar" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tableInqEntry" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tableInqPar" "', argument " "4"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tableInqEntry" "', argument " "4"" of type '" "char *""'");
}
arg4 = (char *)(buf4);
- res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
+ res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "tableInqPar" "', argument " "5"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "tableInqEntry" "', argument " "5"" of type '" "char *""'");
}
arg5 = (char *)(buf5);
- tableInqPar(arg1,arg2,arg3,arg4,arg5);
+ res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "tableInqEntry" "', argument " "6"" of type '" "char *""'");
+ }
+ arg6 = (char *)(buf6);
+ tableInqEntry(arg1,arg2,arg3,arg4,arg5,arg6);
resultobj = SWIG_Py_Void();
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_streamDefHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "streamDefHistory", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefHistory" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefHistory" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamDefHistory" "', argument " "3"" of type '" "char const *""'");
+ }
+ arg3 = (char *)(buf3);
+ streamDefHistory(arg1,arg2,(char const *)arg3);
+ resultobj = SWIG_Py_Void();
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return resultobj;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_streamInqHistorySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqHistorySize" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)streamInqHistorySize(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_streamInqHistoryString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
char *arg2 = (char *) 0 ;
- int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableInqParCode",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "streamInqHistoryString", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParCode" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqHistoryString" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tableInqParCode" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqHistoryString" "', argument " "2"" of type '" "char *""'");
}
arg2 = (char *)(buf2);
- res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInqParCode" "', argument " "3"" of type '" "int *""'");
- }
- arg3 = (int *)(argp3);
- result = (int)tableInqParCode(arg1,arg2,arg3);
+ streamInqHistoryString(arg1,arg2);
+ resultobj = SWIG_Py_Void();
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return resultobj;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_subtypeCreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+ int result;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeCreate" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ result = (int)subtypeCreate(arg1);
+ resultobj = SWIG_From_int((int)(result));
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_subtypePrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ PyObject *swig_obj[1] ;
+
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypePrint" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ subtypePrint(arg1);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_subtypeCompare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
+
+ if (!SWIG_Python_UnpackTuple(args, "subtypeCompare", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeCompare" "', argument " "1"" of type '" "int""'");
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subtypeCompare" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)subtypeCompare(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeInqSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableInqParName",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParName" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeInqSize" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParName" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInqParName" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParName(arg1,arg2,arg3);
+ result = (int)subtypeInqSize(arg1);
resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParLongname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeInqActiveIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ PyObject *swig_obj[1] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableInqParLongname",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!args) SWIG_fail;
+ swig_obj[0] = args;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParLongname" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeInqActiveIndex" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParLongname" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInqParLongname" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParLongname(arg1,arg2,arg3);
+ result = (int)subtypeInqActiveIndex(arg1);
resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeDefActiveIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
- int result;
+ PyObject *swig_obj[2] ;
- if (!PyArg_ParseTuple(args,(char *)"OOO:tableInqParUnits",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "subtypeDefActiveIndex", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParUnits" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeDefActiveIndex" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParUnits" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subtypeDefActiveIndex" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tableInqParUnits" "', argument " "3"" of type '" "char *""'");
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParUnits(arg1,arg2,arg3);
- resultobj = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ subtypeDefActiveIndex(arg1,arg2);
+ resultobj = SWIG_Py_Void();
return resultobj;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParNamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_keyValuePair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
+ char *arg1 = (char *) 0 ;
int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- char *result = 0 ;
+ PyObject *swig_obj[2] ;
+ subtype_query_t result;
- if (!PyArg_ParseTuple(args,(char *)"OO:tableInqParNamePtr",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParNamePtr" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ if (!SWIG_Python_UnpackTuple(args, "keyValuePair", 2, 2, swig_obj)) SWIG_fail;
+ res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "keyValuePair" "', argument " "1"" of type '" "char const *""'");
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParNamePtr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "keyValuePair" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (char *)tableInqParNamePtr(arg1,arg2);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ result = keyValuePair((char const *)arg1,arg2);
+ resultobj = SWIG_NewPointerObj((subtype_query_t *)memcpy((subtype_query_t *)calloc(1,sizeof(subtype_query_t)),&result,sizeof(subtype_query_t)), SWIGTYPE_p_subtype_query_t, SWIG_POINTER_OWN | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return resultobj;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_matchAND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ subtype_query_t arg1 ;
+ subtype_query_t arg2 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ subtype_query_t result;
+
+ if (!SWIG_Python_UnpackTuple(args, "matchAND", 2, 2, swig_obj)) SWIG_fail;
+ {
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matchAND" "', argument " "1"" of type '" "subtype_query_t""'");
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "matchAND" "', argument " "1"" of type '" "subtype_query_t""'");
+ } else {
+ arg1 = *((subtype_query_t *)(argp1));
+ }
+ }
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "matchAND" "', argument " "2"" of type '" "subtype_query_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "matchAND" "', argument " "2"" of type '" "subtype_query_t""'");
+ } else {
+ arg2 = *((subtype_query_t *)(argp2));
+ }
+ }
+ result = matchAND(arg1,arg2);
+ resultobj = SWIG_NewPointerObj((subtype_query_t *)memcpy((subtype_query_t *)calloc(1,sizeof(subtype_query_t)),&result,sizeof(subtype_query_t)), SWIGTYPE_p_subtype_query_t, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParLongnamePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeInqSubEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
- int arg2 ;
+ subtype_query_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- char *result = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ PyObject *swig_obj[2] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:tableInqParLongnamePtr",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "subtypeInqSubEntry", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParLongnamePtr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeInqSubEntry" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParLongnamePtr" "', argument " "2"" of type '" "int""'");
- }
- arg2 = (int)(val2);
- result = (char *)tableInqParLongnamePtr(arg1,arg2);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ {
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subtypeInqSubEntry" "', argument " "2"" of type '" "subtype_query_t""'");
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "subtypeInqSubEntry" "', argument " "2"" of type '" "subtype_query_t""'");
+ } else {
+ arg2 = *((subtype_query_t *)(argp2));
+ }
+ }
+ result = (int)subtypeInqSubEntry(arg1,arg2);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_tableInqParUnitsPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeInqTile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- char *result = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OO:tableInqParUnitsPtr",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "subtypeInqTile", 3, 3, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tableInqParUnitsPtr" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeInqTile" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tableInqParUnitsPtr" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subtypeInqTile" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- result = (char *)tableInqParUnitsPtr(arg1,arg2);
- resultobj = SWIG_FromCharPtr((const char *)result);
+ ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subtypeInqTile" "', argument " "3"" of type '" "int""'");
+ }
+ arg3 = (int)(val3);
+ result = (int)subtypeInqTile(arg1,arg2,arg3);
+ resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
return NULL;
}
-SWIGINTERN PyObject *_wrap_streamDefHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_subtypeInqAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
int arg2 ;
char *arg3 = (char *) 0 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -12227,28 +17911,34 @@ SWIGINTERN PyObject *_wrap_streamDefHistory(PyObject *SWIGUNUSEDPARM(self), PyOb
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
- PyObject * obj2 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ PyObject *swig_obj[4] ;
+ int result;
- if (!PyArg_ParseTuple(args,(char *)"OOO:streamDefHistory",&obj0,&obj1,&obj2)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "subtypeInqAttribute", 4, 4, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamDefHistory" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "subtypeInqAttribute" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(obj1, &val2);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streamDefHistory" "', argument " "2"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subtypeInqAttribute" "', argument " "2"" of type '" "int""'");
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
+ res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "streamDefHistory" "', argument " "3"" of type '" "char const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "subtypeInqAttribute" "', argument " "3"" of type '" "char const *""'");
}
arg3 = (char *)(buf3);
- streamDefHistory(arg1,arg2,(char const *)arg3);
- resultobj = SWIG_Py_Void();
+ res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "subtypeInqAttribute" "', argument " "4"" of type '" "int *""'");
+ }
+ arg4 = (int *)(argp4);
+ result = (int)subtypeInqAttribute(arg1,arg2,(char const *)arg3,arg4);
+ resultobj = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return resultobj;
fail:
@@ -12257,21 +17947,29 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamInqHistorySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vlistInqVarSubtype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- PyObject * obj0 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
int result;
- if (!PyArg_ParseTuple(args,(char *)"O:streamInqHistorySize",&obj0)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
+ if (!SWIG_Python_UnpackTuple(args, "vlistInqVarSubtype", 2, 2, swig_obj)) SWIG_fail;
+ ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqHistorySize" "', argument " "1"" of type '" "int""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlistInqVarSubtype" "', argument " "1"" of type '" "int""'");
}
arg1 = (int)(val1);
- result = (int)streamInqHistorySize(arg1);
+ ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vlistInqVarSubtype" "', argument " "2"" of type '" "int""'");
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarSubtype(arg1,arg2);
resultobj = SWIG_From_int((int)(result));
return resultobj;
fail:
@@ -12279,370 +17977,632 @@ fail:
}
-SWIGINTERN PyObject *_wrap_streamInqHistoryString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_gribapiLibraryVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
- int arg1 ;
- char *arg2 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
- PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
+ int *arg1 = (int *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ PyObject *swig_obj[3] ;
- if (!PyArg_ParseTuple(args,(char *)"OO:streamInqHistoryString",&obj0,&obj1)) SWIG_fail;
- ecode1 = SWIG_AsVal_int(obj0, &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "streamInqHistoryString" "', argument " "1"" of type '" "int""'");
- }
- arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
+ if (!SWIG_Python_UnpackTuple(args, "gribapiLibraryVersion", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gribapiLibraryVersion" "', argument " "1"" of type '" "int *""'");
+ }
+ arg1 = (int *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streamInqHistoryString" "', argument " "2"" of type '" "char *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gribapiLibraryVersion" "', argument " "2"" of type '" "int *""'");
}
- arg2 = (char *)(buf2);
- streamInqHistoryString(arg1,arg2);
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gribapiLibraryVersion" "', argument " "3"" of type '" "int *""'");
+ }
+ arg3 = (int *)(argp3);
+ gribapiLibraryVersion(arg1,arg2,arg3);
+ resultobj = SWIG_Py_Void();
+ return resultobj;
+fail:
+ return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_gaussianLatitudes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+ PyObject *resultobj = 0;
+ double *arg1 = (double *) 0 ;
+ double *arg2 = (double *) 0 ;
+ size_t arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
+
+ if (!SWIG_Python_UnpackTuple(args, "gaussianLatitudes", 3, 3, swig_obj)) SWIG_fail;
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gaussianLatitudes" "', argument " "1"" of type '" "double *""'");
+ }
+ arg1 = (double *)(argp1);
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gaussianLatitudes" "', argument " "2"" of type '" "double *""'");
+ }
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gaussianLatitudes" "', argument " "3"" of type '" "size_t""'");
+ }
+ arg3 = (size_t)(val3);
+ gaussianLatitudes(arg1,arg2,arg3);
resultobj = SWIG_Py_Void();
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return resultobj;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return NULL;
}
static PyMethodDef SwigMethods[] = {
- { (char *)"cdiStringError", _wrap_cdiStringError, METH_VARARGS, NULL},
- { (char *)"cdiDebug", _wrap_cdiDebug, METH_VARARGS, NULL},
- { (char *)"cdiLibraryVersion", _wrap_cdiLibraryVersion, METH_VARARGS, NULL},
- { (char *)"cdiPrintVersion", _wrap_cdiPrintVersion, METH_VARARGS, NULL},
- { (char *)"cdiDefMissval", _wrap_cdiDefMissval, METH_VARARGS, NULL},
- { (char *)"cdiInqMissval", _wrap_cdiInqMissval, METH_VARARGS, NULL},
- { (char *)"cdiDefGlobal", _wrap_cdiDefGlobal, METH_VARARGS, NULL},
- { (char *)"streamOpenRead", _wrap_streamOpenRead, METH_VARARGS, NULL},
- { (char *)"streamOpenWrite", _wrap_streamOpenWrite, METH_VARARGS, NULL},
- { (char *)"streamOpenAppend", _wrap_streamOpenAppend, METH_VARARGS, NULL},
- { (char *)"streamClose", _wrap_streamClose, METH_VARARGS, NULL},
- { (char *)"streamSync", _wrap_streamSync, METH_VARARGS, NULL},
- { (char *)"streamDefVlist", _wrap_streamDefVlist, METH_VARARGS, NULL},
- { (char *)"streamInqVlist", _wrap_streamInqVlist, METH_VARARGS, NULL},
- { (char *)"streamInqFiletype", _wrap_streamInqFiletype, METH_VARARGS, NULL},
- { (char *)"streamDefByteorder", _wrap_streamDefByteorder, METH_VARARGS, NULL},
- { (char *)"streamInqByteorder", _wrap_streamInqByteorder, METH_VARARGS, NULL},
- { (char *)"streamDefZtype", _wrap_streamDefZtype, METH_VARARGS, NULL},
- { (char *)"streamDefZlevel", _wrap_streamDefZlevel, METH_VARARGS, NULL},
- { (char *)"streamInqZtype", _wrap_streamInqZtype, METH_VARARGS, NULL},
- { (char *)"streamInqZlevel", _wrap_streamInqZlevel, METH_VARARGS, NULL},
- { (char *)"streamDefTimestep", _wrap_streamDefTimestep, METH_VARARGS, NULL},
- { (char *)"streamInqTimestep", _wrap_streamInqTimestep, METH_VARARGS, NULL},
- { (char *)"streamFilename", _wrap_streamFilename, METH_VARARGS, NULL},
- { (char *)"streamFilesuffix", _wrap_streamFilesuffix, METH_VARARGS, NULL},
- { (char *)"streamNtsteps", _wrap_streamNtsteps, METH_VARARGS, NULL},
- { (char *)"streamNvals", _wrap_streamNvals, METH_VARARGS, NULL},
- { (char *)"streamReadVar", _wrap_streamReadVar, METH_VARARGS, NULL},
- { (char *)"streamWriteVar", _wrap_streamWriteVar, METH_VARARGS, NULL},
- { (char *)"streamReadVarSlice", _wrap_streamReadVarSlice, METH_VARARGS, NULL},
- { (char *)"streamWriteVarSlice", _wrap_streamWriteVarSlice, METH_VARARGS, NULL},
- { (char *)"streamInqRecord", _wrap_streamInqRecord, METH_VARARGS, NULL},
- { (char *)"streamDefRecord", _wrap_streamDefRecord, METH_VARARGS, NULL},
- { (char *)"streamReadRecord", _wrap_streamReadRecord, METH_VARARGS, NULL},
- { (char *)"streamWriteRecord", _wrap_streamWriteRecord, METH_VARARGS, NULL},
- { (char *)"streamCopyRecord", _wrap_streamCopyRecord, METH_VARARGS, NULL},
- { (char *)"streamInqGinfo", _wrap_streamInqGinfo, METH_VARARGS, NULL},
- { (char *)"vlistCreate", _wrap_vlistCreate, METH_VARARGS, NULL},
- { (char *)"vlistDestroy", _wrap_vlistDestroy, METH_VARARGS, NULL},
- { (char *)"vlistDuplicate", _wrap_vlistDuplicate, METH_VARARGS, NULL},
- { (char *)"vlistCopy", _wrap_vlistCopy, METH_VARARGS, NULL},
- { (char *)"vlistCopyFlag", _wrap_vlistCopyFlag, METH_VARARGS, NULL},
- { (char *)"vlistClearFlag", _wrap_vlistClearFlag, METH_VARARGS, NULL},
- { (char *)"vlistCat", _wrap_vlistCat, METH_VARARGS, NULL},
- { (char *)"vlistMerge", _wrap_vlistMerge, METH_VARARGS, NULL},
- { (char *)"vlistPrint", _wrap_vlistPrint, METH_VARARGS, NULL},
- { (char *)"vlistNvars", _wrap_vlistNvars, METH_VARARGS, NULL},
- { (char *)"vlistNgrids", _wrap_vlistNgrids, METH_VARARGS, NULL},
- { (char *)"vlistNzaxis", _wrap_vlistNzaxis, METH_VARARGS, NULL},
- { (char *)"vlistDefNtsteps", _wrap_vlistDefNtsteps, METH_VARARGS, NULL},
- { (char *)"vlistNtsteps", _wrap_vlistNtsteps, METH_VARARGS, NULL},
- { (char *)"vlistGridsizeMax", _wrap_vlistGridsizeMax, METH_VARARGS, NULL},
- { (char *)"vlistGrid", _wrap_vlistGrid, METH_VARARGS, NULL},
- { (char *)"vlistGridIndex", _wrap_vlistGridIndex, METH_VARARGS, NULL},
- { (char *)"vlistChangeGridIndex", _wrap_vlistChangeGridIndex, METH_VARARGS, NULL},
- { (char *)"vlistChangeGrid", _wrap_vlistChangeGrid, METH_VARARGS, NULL},
- { (char *)"vlistZaxis", _wrap_vlistZaxis, METH_VARARGS, NULL},
- { (char *)"vlistZaxisIndex", _wrap_vlistZaxisIndex, METH_VARARGS, NULL},
- { (char *)"vlistChangeZaxisIndex", _wrap_vlistChangeZaxisIndex, METH_VARARGS, NULL},
- { (char *)"vlistChangeZaxis", _wrap_vlistChangeZaxis, METH_VARARGS, NULL},
- { (char *)"vlistNrecs", _wrap_vlistNrecs, METH_VARARGS, NULL},
- { (char *)"vlistDefTaxis", _wrap_vlistDefTaxis, METH_VARARGS, NULL},
- { (char *)"vlistInqTaxis", _wrap_vlistInqTaxis, METH_VARARGS, NULL},
- { (char *)"vlistDefTable", _wrap_vlistDefTable, METH_VARARGS, NULL},
- { (char *)"vlistInqTable", _wrap_vlistInqTable, METH_VARARGS, NULL},
- { (char *)"vlistDefInstitut", _wrap_vlistDefInstitut, METH_VARARGS, NULL},
- { (char *)"vlistInqInstitut", _wrap_vlistInqInstitut, METH_VARARGS, NULL},
- { (char *)"vlistDefModel", _wrap_vlistDefModel, METH_VARARGS, NULL},
- { (char *)"vlistInqModel", _wrap_vlistInqModel, METH_VARARGS, NULL},
- { (char *)"vlistDefVar", _wrap_vlistDefVar, METH_VARARGS, NULL},
- { (char *)"vlistChangeVarGrid", _wrap_vlistChangeVarGrid, METH_VARARGS, NULL},
- { (char *)"vlistChangeVarZaxis", _wrap_vlistChangeVarZaxis, METH_VARARGS, NULL},
- { (char *)"vlistInqVar", _wrap_vlistInqVar, METH_VARARGS, NULL},
- { (char *)"vlistInqVarGrid", _wrap_vlistInqVarGrid, METH_VARARGS, NULL},
- { (char *)"vlistInqVarZaxis", _wrap_vlistInqVarZaxis, METH_VARARGS, NULL},
- { (char *)"vlistInqVarTime", _wrap_vlistInqVarTime, METH_VARARGS, NULL},
- { (char *)"vlistDefVarZtype", _wrap_vlistDefVarZtype, METH_VARARGS, NULL},
- { (char *)"vlistInqVarZtype", _wrap_vlistInqVarZtype, METH_VARARGS, NULL},
- { (char *)"vlistDefVarZlevel", _wrap_vlistDefVarZlevel, METH_VARARGS, NULL},
- { (char *)"vlistInqVarZlevel", _wrap_vlistInqVarZlevel, METH_VARARGS, NULL},
- { (char *)"vlistDefVarCode", _wrap_vlistDefVarCode, METH_VARARGS, NULL},
- { (char *)"vlistInqVarCode", _wrap_vlistInqVarCode, METH_VARARGS, NULL},
- { (char *)"vlistDefVarDatatype", _wrap_vlistDefVarDatatype, METH_VARARGS, NULL},
- { (char *)"vlistInqVarDatatype", _wrap_vlistInqVarDatatype, METH_VARARGS, NULL},
- { (char *)"vlistDefVarInstitut", _wrap_vlistDefVarInstitut, METH_VARARGS, NULL},
- { (char *)"vlistInqVarInstitut", _wrap_vlistInqVarInstitut, METH_VARARGS, NULL},
- { (char *)"vlistDefVarModel", _wrap_vlistDefVarModel, METH_VARARGS, NULL},
- { (char *)"vlistInqVarModel", _wrap_vlistInqVarModel, METH_VARARGS, NULL},
- { (char *)"vlistDefVarTable", _wrap_vlistDefVarTable, METH_VARARGS, NULL},
- { (char *)"vlistInqVarTable", _wrap_vlistInqVarTable, METH_VARARGS, NULL},
- { (char *)"vlistDefVarName", _wrap_vlistDefVarName, METH_VARARGS, NULL},
- { (char *)"vlistInqVarName", _wrap_vlistInqVarName, METH_VARARGS, NULL},
- { (char *)"vlistDefVarLongname", _wrap_vlistDefVarLongname, METH_VARARGS, NULL},
- { (char *)"vlistDefVarStdname", _wrap_vlistDefVarStdname, METH_VARARGS, NULL},
- { (char *)"vlistInqVarLongname", _wrap_vlistInqVarLongname, METH_VARARGS, NULL},
- { (char *)"vlistInqVarStdname", _wrap_vlistInqVarStdname, METH_VARARGS, NULL},
- { (char *)"vlistDefVarUnits", _wrap_vlistDefVarUnits, METH_VARARGS, NULL},
- { (char *)"vlistInqVarUnits", _wrap_vlistInqVarUnits, METH_VARARGS, NULL},
- { (char *)"vlistDefVarMissval", _wrap_vlistDefVarMissval, METH_VARARGS, NULL},
- { (char *)"vlistInqVarMissval", _wrap_vlistInqVarMissval, METH_VARARGS, NULL},
- { (char *)"vlistDefVarScalefactor", _wrap_vlistDefVarScalefactor, METH_VARARGS, NULL},
- { (char *)"vlistInqVarScalefactor", _wrap_vlistInqVarScalefactor, METH_VARARGS, NULL},
- { (char *)"vlistDefVarAddoffset", _wrap_vlistDefVarAddoffset, METH_VARARGS, NULL},
- { (char *)"vlistInqVarAddoffset", _wrap_vlistInqVarAddoffset, METH_VARARGS, NULL},
- { (char *)"vlistDefVarTimave", _wrap_vlistDefVarTimave, METH_VARARGS, NULL},
- { (char *)"vlistInqVarTimave", _wrap_vlistInqVarTimave, METH_VARARGS, NULL},
- { (char *)"vlistDefVarTimaccu", _wrap_vlistDefVarTimaccu, METH_VARARGS, NULL},
- { (char *)"vlistInqVarTimaccu", _wrap_vlistInqVarTimaccu, METH_VARARGS, NULL},
- { (char *)"vlistInqVarSize", _wrap_vlistInqVarSize, METH_VARARGS, NULL},
- { (char *)"vlistInqVarID", _wrap_vlistInqVarID, METH_VARARGS, NULL},
- { (char *)"vlistDefIndex", _wrap_vlistDefIndex, METH_VARARGS, NULL},
- { (char *)"vlistInqIndex", _wrap_vlistInqIndex, METH_VARARGS, NULL},
- { (char *)"vlistDefFlag", _wrap_vlistDefFlag, METH_VARARGS, NULL},
- { (char *)"vlistInqFlag", _wrap_vlistInqFlag, METH_VARARGS, NULL},
- { (char *)"vlistFindVar", _wrap_vlistFindVar, METH_VARARGS, NULL},
- { (char *)"vlistFindLevel", _wrap_vlistFindLevel, METH_VARARGS, NULL},
- { (char *)"vlistMergedVar", _wrap_vlistMergedVar, METH_VARARGS, NULL},
- { (char *)"vlistMergedLevel", _wrap_vlistMergedLevel, METH_VARARGS, NULL},
- { (char *)"vlistInqNatts", _wrap_vlistInqNatts, METH_VARARGS, NULL},
- { (char *)"vlistInqAtt", _wrap_vlistInqAtt, METH_VARARGS, NULL},
- { (char *)"vlistDelAtt", _wrap_vlistDelAtt, METH_VARARGS, NULL},
- { (char *)"vlistDefAttInt", _wrap_vlistDefAttInt, METH_VARARGS, NULL},
- { (char *)"vlistDefAttFlt", _wrap_vlistDefAttFlt, METH_VARARGS, NULL},
- { (char *)"vlistDefAttTxt", _wrap_vlistDefAttTxt, METH_VARARGS, NULL},
- { (char *)"vlistInqAttInt", _wrap_vlistInqAttInt, METH_VARARGS, NULL},
- { (char *)"vlistInqAttFlt", _wrap_vlistInqAttFlt, METH_VARARGS, NULL},
- { (char *)"vlistInqAttTxt", _wrap_vlistInqAttTxt, METH_VARARGS, NULL},
- { (char *)"gridName", _wrap_gridName, METH_VARARGS, NULL},
- { (char *)"gridNamePtr", _wrap_gridNamePtr, METH_VARARGS, NULL},
- { (char *)"gridCompress", _wrap_gridCompress, METH_VARARGS, NULL},
- { (char *)"gridDefMask", _wrap_gridDefMask, METH_VARARGS, NULL},
- { (char *)"gridInqMask", _wrap_gridInqMask, METH_VARARGS, NULL},
- { (char *)"gridPrint", _wrap_gridPrint, METH_VARARGS, NULL},
- { (char *)"gridSize", _wrap_gridSize, METH_VARARGS, NULL},
- { (char *)"gridCreate", _wrap_gridCreate, METH_VARARGS, NULL},
- { (char *)"gridDestroy", _wrap_gridDestroy, METH_VARARGS, NULL},
- { (char *)"gridDuplicate", _wrap_gridDuplicate, METH_VARARGS, NULL},
- { (char *)"gridInqType", _wrap_gridInqType, METH_VARARGS, NULL},
- { (char *)"gridInqSize", _wrap_gridInqSize, METH_VARARGS, NULL},
- { (char *)"gridDefXsize", _wrap_gridDefXsize, METH_VARARGS, NULL},
- { (char *)"gridInqXsize", _wrap_gridInqXsize, METH_VARARGS, NULL},
- { (char *)"gridDefYsize", _wrap_gridDefYsize, METH_VARARGS, NULL},
- { (char *)"gridInqYsize", _wrap_gridInqYsize, METH_VARARGS, NULL},
- { (char *)"gridDefXvals", _wrap_gridDefXvals, METH_VARARGS, NULL},
- { (char *)"gridInqXvals", _wrap_gridInqXvals, METH_VARARGS, NULL},
- { (char *)"gridDefYvals", _wrap_gridDefYvals, METH_VARARGS, NULL},
- { (char *)"gridInqYvals", _wrap_gridInqYvals, METH_VARARGS, NULL},
- { (char *)"gridDefXname", _wrap_gridDefXname, METH_VARARGS, NULL},
- { (char *)"gridDefXlongname", _wrap_gridDefXlongname, METH_VARARGS, NULL},
- { (char *)"gridDefXunits", _wrap_gridDefXunits, METH_VARARGS, NULL},
- { (char *)"gridDefYname", _wrap_gridDefYname, METH_VARARGS, NULL},
- { (char *)"gridDefYlongname", _wrap_gridDefYlongname, METH_VARARGS, NULL},
- { (char *)"gridDefYunits", _wrap_gridDefYunits, METH_VARARGS, NULL},
- { (char *)"gridInqXname", _wrap_gridInqXname, METH_VARARGS, NULL},
- { (char *)"gridInqXlongname", _wrap_gridInqXlongname, METH_VARARGS, NULL},
- { (char *)"gridInqXstdname", _wrap_gridInqXstdname, METH_VARARGS, NULL},
- { (char *)"gridInqXunits", _wrap_gridInqXunits, METH_VARARGS, NULL},
- { (char *)"gridInqYname", _wrap_gridInqYname, METH_VARARGS, NULL},
- { (char *)"gridInqYlongname", _wrap_gridInqYlongname, METH_VARARGS, NULL},
- { (char *)"gridInqYstdname", _wrap_gridInqYstdname, METH_VARARGS, NULL},
- { (char *)"gridInqYunits", _wrap_gridInqYunits, METH_VARARGS, NULL},
- { (char *)"gridDefDatatype", _wrap_gridDefDatatype, METH_VARARGS, NULL},
- { (char *)"gridInqDatatype", _wrap_gridInqDatatype, METH_VARARGS, NULL},
- { (char *)"gridInqXval", _wrap_gridInqXval, METH_VARARGS, NULL},
- { (char *)"gridInqYval", _wrap_gridInqYval, METH_VARARGS, NULL},
- { (char *)"gridInqXinc", _wrap_gridInqXinc, METH_VARARGS, NULL},
- { (char *)"gridInqYinc", _wrap_gridInqYinc, METH_VARARGS, NULL},
- { (char *)"gridIsCircular", _wrap_gridIsCircular, METH_VARARGS, NULL},
- { (char *)"gridIsRotated", _wrap_gridIsRotated, METH_VARARGS, NULL},
- { (char *)"gridInqXpole", _wrap_gridInqXpole, METH_VARARGS, NULL},
- { (char *)"gridDefXpole", _wrap_gridDefXpole, METH_VARARGS, NULL},
- { (char *)"gridInqYpole", _wrap_gridInqYpole, METH_VARARGS, NULL},
- { (char *)"gridDefYpole", _wrap_gridDefYpole, METH_VARARGS, NULL},
- { (char *)"gridInqAngle", _wrap_gridInqAngle, METH_VARARGS, NULL},
- { (char *)"gridDefAngle", _wrap_gridDefAngle, METH_VARARGS, NULL},
- { (char *)"gridDefTrunc", _wrap_gridDefTrunc, METH_VARARGS, NULL},
- { (char *)"gridInqTrunc", _wrap_gridInqTrunc, METH_VARARGS, NULL},
- { (char *)"gridInqGMEnd", _wrap_gridInqGMEnd, METH_VARARGS, NULL},
- { (char *)"gridDefGMEnd", _wrap_gridDefGMEnd, METH_VARARGS, NULL},
- { (char *)"gridInqGMEni", _wrap_gridInqGMEni, METH_VARARGS, NULL},
- { (char *)"gridDefGMEni", _wrap_gridDefGMEni, METH_VARARGS, NULL},
- { (char *)"gridInqGMEni2", _wrap_gridInqGMEni2, METH_VARARGS, NULL},
- { (char *)"gridDefGMEni2", _wrap_gridDefGMEni2, METH_VARARGS, NULL},
- { (char *)"gridInqGMEni3", _wrap_gridInqGMEni3, METH_VARARGS, NULL},
- { (char *)"gridDefGMEni3", _wrap_gridDefGMEni3, METH_VARARGS, NULL},
- { (char *)"gridDefLCC", _wrap_gridDefLCC, METH_VARARGS, NULL},
- { (char *)"gridInqLCC", _wrap_gridInqLCC, METH_VARARGS, NULL},
- { (char *)"gridDefLcc2", _wrap_gridDefLcc2, METH_VARARGS, NULL},
- { (char *)"gridInqLcc2", _wrap_gridInqLcc2, METH_VARARGS, NULL},
- { (char *)"gridDefLaea", _wrap_gridDefLaea, METH_VARARGS, NULL},
- { (char *)"gridInqLaea", _wrap_gridInqLaea, METH_VARARGS, NULL},
- { (char *)"gridDefArea", _wrap_gridDefArea, METH_VARARGS, NULL},
- { (char *)"gridInqArea", _wrap_gridInqArea, METH_VARARGS, NULL},
- { (char *)"gridHasArea", _wrap_gridHasArea, METH_VARARGS, NULL},
- { (char *)"gridDefNvertex", _wrap_gridDefNvertex, METH_VARARGS, NULL},
- { (char *)"gridInqNvertex", _wrap_gridInqNvertex, METH_VARARGS, NULL},
- { (char *)"gridDefXbounds", _wrap_gridDefXbounds, METH_VARARGS, NULL},
- { (char *)"gridInqXbounds", _wrap_gridInqXbounds, METH_VARARGS, NULL},
- { (char *)"gridDefYbounds", _wrap_gridDefYbounds, METH_VARARGS, NULL},
- { (char *)"gridInqYbounds", _wrap_gridInqYbounds, METH_VARARGS, NULL},
- { (char *)"gridDefRowlon", _wrap_gridDefRowlon, METH_VARARGS, NULL},
- { (char *)"gridInqRowlon", _wrap_gridInqRowlon, METH_VARARGS, NULL},
- { (char *)"gridChangeType", _wrap_gridChangeType, METH_VARARGS, NULL},
- { (char *)"zaxisName", _wrap_zaxisName, METH_VARARGS, NULL},
- { (char *)"zaxisCreate", _wrap_zaxisCreate, METH_VARARGS, NULL},
- { (char *)"zaxisDestroy", _wrap_zaxisDestroy, METH_VARARGS, NULL},
- { (char *)"zaxisInqType", _wrap_zaxisInqType, METH_VARARGS, NULL},
- { (char *)"zaxisInqSize", _wrap_zaxisInqSize, METH_VARARGS, NULL},
- { (char *)"zaxisDuplicate", _wrap_zaxisDuplicate, METH_VARARGS, NULL},
- { (char *)"zaxisResize", _wrap_zaxisResize, METH_VARARGS, NULL},
- { (char *)"zaxisPrint", _wrap_zaxisPrint, METH_VARARGS, NULL},
- { (char *)"zaxisSize", _wrap_zaxisSize, METH_VARARGS, NULL},
- { (char *)"zaxisDefLevels", _wrap_zaxisDefLevels, METH_VARARGS, NULL},
- { (char *)"zaxisInqLevels", _wrap_zaxisInqLevels, METH_VARARGS, NULL},
- { (char *)"zaxisDefLevel", _wrap_zaxisDefLevel, METH_VARARGS, NULL},
- { (char *)"zaxisInqLevel", _wrap_zaxisInqLevel, METH_VARARGS, NULL},
- { (char *)"zaxisDefName", _wrap_zaxisDefName, METH_VARARGS, NULL},
- { (char *)"zaxisDefLongname", _wrap_zaxisDefLongname, METH_VARARGS, NULL},
- { (char *)"zaxisDefUnits", _wrap_zaxisDefUnits, METH_VARARGS, NULL},
- { (char *)"zaxisInqName", _wrap_zaxisInqName, METH_VARARGS, NULL},
- { (char *)"zaxisInqLongname", _wrap_zaxisInqLongname, METH_VARARGS, NULL},
- { (char *)"zaxisInqUnits", _wrap_zaxisInqUnits, METH_VARARGS, NULL},
- { (char *)"zaxisDefDatatype", _wrap_zaxisDefDatatype, METH_VARARGS, NULL},
- { (char *)"zaxisInqDatatype", _wrap_zaxisInqDatatype, METH_VARARGS, NULL},
- { (char *)"zaxisDefLtype", _wrap_zaxisDefLtype, METH_VARARGS, NULL},
- { (char *)"zaxisInqLtype", _wrap_zaxisInqLtype, METH_VARARGS, NULL},
- { (char *)"zaxisInqLevelsPtr", _wrap_zaxisInqLevelsPtr, METH_VARARGS, NULL},
- { (char *)"zaxisDefVct", _wrap_zaxisDefVct, METH_VARARGS, NULL},
- { (char *)"zaxisInqVctSize", _wrap_zaxisInqVctSize, METH_VARARGS, NULL},
- { (char *)"zaxisInqVctPtr", _wrap_zaxisInqVctPtr, METH_VARARGS, NULL},
- { (char *)"zaxisInqLbounds", _wrap_zaxisInqLbounds, METH_VARARGS, NULL},
- { (char *)"zaxisInqUbounds", _wrap_zaxisInqUbounds, METH_VARARGS, NULL},
- { (char *)"zaxisInqWeights", _wrap_zaxisInqWeights, METH_VARARGS, NULL},
- { (char *)"zaxisInqLbound", _wrap_zaxisInqLbound, METH_VARARGS, NULL},
- { (char *)"zaxisInqUbound", _wrap_zaxisInqUbound, METH_VARARGS, NULL},
- { (char *)"zaxisDefLbounds", _wrap_zaxisDefLbounds, METH_VARARGS, NULL},
- { (char *)"zaxisDefUbounds", _wrap_zaxisDefUbounds, METH_VARARGS, NULL},
- { (char *)"zaxisDefWeights", _wrap_zaxisDefWeights, METH_VARARGS, NULL},
- { (char *)"zaxisChangeType", _wrap_zaxisChangeType, METH_VARARGS, NULL},
- { (char *)"taxisCreate", _wrap_taxisCreate, METH_VARARGS, NULL},
- { (char *)"taxisDestroy", _wrap_taxisDestroy, METH_VARARGS, NULL},
- { (char *)"taxisDuplicate", _wrap_taxisDuplicate, METH_VARARGS, NULL},
- { (char *)"taxisCopyTimestep", _wrap_taxisCopyTimestep, METH_VARARGS, NULL},
- { (char *)"taxisDefType", _wrap_taxisDefType, METH_VARARGS, NULL},
- { (char *)"taxisDefVdate", _wrap_taxisDefVdate, METH_VARARGS, NULL},
- { (char *)"taxisDefVtime", _wrap_taxisDefVtime, METH_VARARGS, NULL},
- { (char *)"taxisDefRdate", _wrap_taxisDefRdate, METH_VARARGS, NULL},
- { (char *)"taxisDefRtime", _wrap_taxisDefRtime, METH_VARARGS, NULL},
- { (char *)"taxisHasBounds", _wrap_taxisHasBounds, METH_VARARGS, NULL},
- { (char *)"taxisDefVdateBounds", _wrap_taxisDefVdateBounds, METH_VARARGS, NULL},
- { (char *)"taxisDefVtimeBounds", _wrap_taxisDefVtimeBounds, METH_VARARGS, NULL},
- { (char *)"taxisInqVdateBounds", _wrap_taxisInqVdateBounds, METH_VARARGS, NULL},
- { (char *)"taxisInqVtimeBounds", _wrap_taxisInqVtimeBounds, METH_VARARGS, NULL},
- { (char *)"taxisDefCalendar", _wrap_taxisDefCalendar, METH_VARARGS, NULL},
- { (char *)"taxisDefTunit", _wrap_taxisDefTunit, METH_VARARGS, NULL},
- { (char *)"taxisDefNumavg", _wrap_taxisDefNumavg, METH_VARARGS, NULL},
- { (char *)"taxisInqType", _wrap_taxisInqType, METH_VARARGS, NULL},
- { (char *)"taxisInqVdate", _wrap_taxisInqVdate, METH_VARARGS, NULL},
- { (char *)"taxisInqVtime", _wrap_taxisInqVtime, METH_VARARGS, NULL},
- { (char *)"taxisInqRdate", _wrap_taxisInqRdate, METH_VARARGS, NULL},
- { (char *)"taxisInqRtime", _wrap_taxisInqRtime, METH_VARARGS, NULL},
- { (char *)"taxisInqCalendar", _wrap_taxisInqCalendar, METH_VARARGS, NULL},
- { (char *)"taxisInqTunit", _wrap_taxisInqTunit, METH_VARARGS, NULL},
- { (char *)"taxisInqNumavg", _wrap_taxisInqNumavg, METH_VARARGS, NULL},
- { (char *)"tunitNamePtr", _wrap_tunitNamePtr, METH_VARARGS, NULL},
- { (char *)"institutDef", _wrap_institutDef, METH_VARARGS, NULL},
- { (char *)"institutInq", _wrap_institutInq, METH_VARARGS, NULL},
- { (char *)"institutInqNumber", _wrap_institutInqNumber, METH_VARARGS, NULL},
- { (char *)"institutInqCenter", _wrap_institutInqCenter, METH_VARARGS, NULL},
- { (char *)"institutInqSubcenter", _wrap_institutInqSubcenter, METH_VARARGS, NULL},
- { (char *)"institutInqNamePtr", _wrap_institutInqNamePtr, METH_VARARGS, NULL},
- { (char *)"institutInqLongnamePtr", _wrap_institutInqLongnamePtr, METH_VARARGS, NULL},
- { (char *)"modelDef", _wrap_modelDef, METH_VARARGS, NULL},
- { (char *)"modelInq", _wrap_modelInq, METH_VARARGS, NULL},
- { (char *)"modelInqInstitut", _wrap_modelInqInstitut, METH_VARARGS, NULL},
- { (char *)"modelInqGribID", _wrap_modelInqGribID, METH_VARARGS, NULL},
- { (char *)"modelInqNamePtr", _wrap_modelInqNamePtr, METH_VARARGS, NULL},
- { (char *)"tableWriteC", _wrap_tableWriteC, METH_VARARGS, NULL},
- { (char *)"tableWrite", _wrap_tableWrite, METH_VARARGS, NULL},
- { (char *)"tableRead", _wrap_tableRead, METH_VARARGS, NULL},
- { (char *)"tableDef", _wrap_tableDef, METH_VARARGS, NULL},
- { (char *)"tableInqNamePtr", _wrap_tableInqNamePtr, METH_VARARGS, NULL},
- { (char *)"tableDefEntry", _wrap_tableDefEntry, METH_VARARGS, NULL},
- { (char *)"tableInq", _wrap_tableInq, METH_VARARGS, NULL},
- { (char *)"tableInqNumber", _wrap_tableInqNumber, METH_VARARGS, NULL},
- { (char *)"tableInqNum", _wrap_tableInqNum, METH_VARARGS, NULL},
- { (char *)"tableInqModel", _wrap_tableInqModel, METH_VARARGS, NULL},
- { (char *)"tableInqPar", _wrap_tableInqPar, METH_VARARGS, NULL},
- { (char *)"tableInqParCode", _wrap_tableInqParCode, METH_VARARGS, NULL},
- { (char *)"tableInqParName", _wrap_tableInqParName, METH_VARARGS, NULL},
- { (char *)"tableInqParLongname", _wrap_tableInqParLongname, METH_VARARGS, NULL},
- { (char *)"tableInqParUnits", _wrap_tableInqParUnits, METH_VARARGS, NULL},
- { (char *)"tableInqParNamePtr", _wrap_tableInqParNamePtr, METH_VARARGS, NULL},
- { (char *)"tableInqParLongnamePtr", _wrap_tableInqParLongnamePtr, METH_VARARGS, NULL},
- { (char *)"tableInqParUnitsPtr", _wrap_tableInqParUnitsPtr, METH_VARARGS, NULL},
- { (char *)"streamDefHistory", _wrap_streamDefHistory, METH_VARARGS, NULL},
- { (char *)"streamInqHistorySize", _wrap_streamInqHistorySize, METH_VARARGS, NULL},
- { (char *)"streamInqHistoryString", _wrap_streamInqHistoryString, METH_VARARGS, NULL},
+ { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
+ { "subtype_query_t_nAND_set", _wrap_subtype_query_t_nAND_set, METH_VARARGS, NULL},
+ { "subtype_query_t_nAND_get", _wrap_subtype_query_t_nAND_get, METH_O, NULL},
+ { "subtype_query_t_key_value_pairs_set", _wrap_subtype_query_t_key_value_pairs_set, METH_VARARGS, NULL},
+ { "subtype_query_t_key_value_pairs_get", _wrap_subtype_query_t_key_value_pairs_get, METH_O, NULL},
+ { "new_subtype_query_t", _wrap_new_subtype_query_t, METH_NOARGS, NULL},
+ { "delete_subtype_query_t", _wrap_delete_subtype_query_t, METH_O, NULL},
+ { "subtype_query_t_swigregister", subtype_query_t_swigregister, METH_O, NULL},
+ { "subtype_query_t_swiginit", subtype_query_t_swiginit, METH_VARARGS, NULL},
+ { "CdiParam_discipline_set", _wrap_CdiParam_discipline_set, METH_VARARGS, NULL},
+ { "CdiParam_discipline_get", _wrap_CdiParam_discipline_get, METH_O, NULL},
+ { "CdiParam_category_set", _wrap_CdiParam_category_set, METH_VARARGS, NULL},
+ { "CdiParam_category_get", _wrap_CdiParam_category_get, METH_O, NULL},
+ { "CdiParam_number_set", _wrap_CdiParam_number_set, METH_VARARGS, NULL},
+ { "CdiParam_number_get", _wrap_CdiParam_number_get, METH_O, NULL},
+ { "new_CdiParam", _wrap_new_CdiParam, METH_NOARGS, NULL},
+ { "delete_CdiParam", _wrap_delete_CdiParam, METH_O, NULL},
+ { "CdiParam_swigregister", CdiParam_swigregister, METH_O, NULL},
+ { "CdiParam_swiginit", CdiParam_swiginit, METH_VARARGS, NULL},
+ { "cdiReset", _wrap_cdiReset, METH_NOARGS, NULL},
+ { "cdiStringError", _wrap_cdiStringError, METH_O, NULL},
+ { "cdiDebug", _wrap_cdiDebug, METH_O, NULL},
+ { "cdiLibraryVersion", _wrap_cdiLibraryVersion, METH_NOARGS, NULL},
+ { "cdiPrintVersion", _wrap_cdiPrintVersion, METH_NOARGS, NULL},
+ { "cdiHaveFiletype", _wrap_cdiHaveFiletype, METH_O, NULL},
+ { "cdiDefMissval", _wrap_cdiDefMissval, METH_O, NULL},
+ { "cdiInqMissval", _wrap_cdiInqMissval, METH_NOARGS, NULL},
+ { "cdiInqGridMissval", _wrap_cdiInqGridMissval, METH_NOARGS, NULL},
+ { "cdiDefGlobal", _wrap_cdiDefGlobal, METH_VARARGS, NULL},
+ { "namespaceNew", _wrap_namespaceNew, METH_NOARGS, NULL},
+ { "namespaceSetActive", _wrap_namespaceSetActive, METH_O, NULL},
+ { "namespaceGetActive", _wrap_namespaceGetActive, METH_NOARGS, NULL},
+ { "namespaceDelete", _wrap_namespaceDelete, METH_O, NULL},
+ { "cdiParamToString", _wrap_cdiParamToString, METH_VARARGS, NULL},
+ { "cdiDecodeParam", _wrap_cdiDecodeParam, METH_VARARGS, NULL},
+ { "cdiEncodeParam", _wrap_cdiEncodeParam, METH_VARARGS, NULL},
+ { "cdiDecodeDate", _wrap_cdiDecodeDate, METH_VARARGS, NULL},
+ { "cdiEncodeDate", _wrap_cdiEncodeDate, METH_VARARGS, NULL},
+ { "cdiDecodeTime", _wrap_cdiDecodeTime, METH_VARARGS, NULL},
+ { "cdiEncodeTime", _wrap_cdiEncodeTime, METH_VARARGS, NULL},
+ { "cdiGetFiletype", _wrap_cdiGetFiletype, METH_VARARGS, NULL},
+ { "streamOpenRead", _wrap_streamOpenRead, METH_O, NULL},
+ { "streamOpenWrite", _wrap_streamOpenWrite, METH_VARARGS, NULL},
+ { "streamOpenAppend", _wrap_streamOpenAppend, METH_O, NULL},
+ { "streamClose", _wrap_streamClose, METH_O, NULL},
+ { "streamSync", _wrap_streamSync, METH_O, NULL},
+ { "streamDefNumWorker", _wrap_streamDefNumWorker, METH_VARARGS, NULL},
+ { "streamDefVlist", _wrap_streamDefVlist, METH_VARARGS, NULL},
+ { "streamInqVlist", _wrap_streamInqVlist, METH_O, NULL},
+ { "streamInqFiletype", _wrap_streamInqFiletype, METH_O, NULL},
+ { "streamDefByteorder", _wrap_streamDefByteorder, METH_VARARGS, NULL},
+ { "streamInqByteorder", _wrap_streamInqByteorder, METH_O, NULL},
+ { "streamDefCompType", _wrap_streamDefCompType, METH_VARARGS, NULL},
+ { "streamInqCompType", _wrap_streamInqCompType, METH_O, NULL},
+ { "streamDefCompLevel", _wrap_streamDefCompLevel, METH_VARARGS, NULL},
+ { "streamInqCompLevel", _wrap_streamInqCompLevel, METH_O, NULL},
+ { "streamDefTimestep", _wrap_streamDefTimestep, METH_VARARGS, NULL},
+ { "streamInqTimestep", _wrap_streamInqTimestep, METH_VARARGS, NULL},
+ { "streamInqCurTimestepID", _wrap_streamInqCurTimestepID, METH_O, NULL},
+ { "streamFilename", _wrap_streamFilename, METH_O, NULL},
+ { "streamFilesuffix", _wrap_streamFilesuffix, METH_O, NULL},
+ { "streamNvals", _wrap_streamNvals, METH_O, NULL},
+ { "streamInqNvars", _wrap_streamInqNvars, METH_O, NULL},
+ { "streamWriteVar", _wrap_streamWriteVar, METH_VARARGS, NULL},
+ { "streamWriteVarF", _wrap_streamWriteVarF, METH_VARARGS, NULL},
+ { "streamReadVar", _wrap_streamReadVar, METH_VARARGS, NULL},
+ { "streamReadVarF", _wrap_streamReadVarF, METH_VARARGS, NULL},
+ { "streamReadVarPart", _wrap_streamReadVarPart, METH_VARARGS, NULL},
+ { "streamWriteVarSlice", _wrap_streamWriteVarSlice, METH_VARARGS, NULL},
+ { "streamWriteVarSliceF", _wrap_streamWriteVarSliceF, METH_VARARGS, NULL},
+ { "streamReadVarSlicePart", _wrap_streamReadVarSlicePart, METH_VARARGS, NULL},
+ { "streamReadVarSlice", _wrap_streamReadVarSlice, METH_VARARGS, NULL},
+ { "streamReadVarSliceF", _wrap_streamReadVarSliceF, METH_VARARGS, NULL},
+ { "streamWriteVarChunk", _wrap_streamWriteVarChunk, METH_VARARGS, NULL},
+ { "streamDefRecord", _wrap_streamDefRecord, METH_VARARGS, NULL},
+ { "streamInqRecord", _wrap_streamInqRecord, METH_VARARGS, NULL},
+ { "streamWriteRecord", _wrap_streamWriteRecord, METH_VARARGS, NULL},
+ { "streamWriteRecordF", _wrap_streamWriteRecordF, METH_VARARGS, NULL},
+ { "streamReadRecord", _wrap_streamReadRecord, METH_VARARGS, NULL},
+ { "streamReadRecordF", _wrap_streamReadRecordF, METH_VARARGS, NULL},
+ { "streamCopyRecord", _wrap_streamCopyRecord, METH_VARARGS, NULL},
+ { "streamInqGRIBinfo", _wrap_streamInqGRIBinfo, METH_VARARGS, NULL},
+ { "cdiIterator_new", _wrap_cdiIterator_new, METH_O, NULL},
+ { "cdiIterator_clone", _wrap_cdiIterator_clone, METH_O, NULL},
+ { "cdiIterator_serialize", _wrap_cdiIterator_serialize, METH_O, NULL},
+ { "cdiIterator_deserialize", _wrap_cdiIterator_deserialize, METH_O, NULL},
+ { "cdiIterator_print", _wrap_cdiIterator_print, METH_VARARGS, NULL},
+ { "cdiIterator_delete", _wrap_cdiIterator_delete, METH_O, NULL},
+ { "cdiIterator_nextField", _wrap_cdiIterator_nextField, METH_O, NULL},
+ { "cdiIterator_inqStartTime", _wrap_cdiIterator_inqStartTime, METH_O, NULL},
+ { "cdiIterator_inqEndTime", _wrap_cdiIterator_inqEndTime, METH_O, NULL},
+ { "cdiIterator_inqRTime", _wrap_cdiIterator_inqRTime, METH_O, NULL},
+ { "cdiIterator_inqVTime", _wrap_cdiIterator_inqVTime, METH_O, NULL},
+ { "cdiIterator_inqLevelType", _wrap_cdiIterator_inqLevelType, METH_VARARGS, NULL},
+ { "cdiIterator_inqLevel", _wrap_cdiIterator_inqLevel, METH_VARARGS, NULL},
+ { "cdiIterator_inqLevelUuid", _wrap_cdiIterator_inqLevelUuid, METH_VARARGS, NULL},
+ { "cdiIterator_inqTile", _wrap_cdiIterator_inqTile, METH_VARARGS, NULL},
+ { "cdiIterator_inqTileCount", _wrap_cdiIterator_inqTileCount, METH_VARARGS, NULL},
+ { "cdiIterator_inqParam", _wrap_cdiIterator_inqParam, METH_O, NULL},
+ { "cdiIterator_inqParamParts", _wrap_cdiIterator_inqParamParts, METH_VARARGS, NULL},
+ { "cdiIterator_inqDatatype", _wrap_cdiIterator_inqDatatype, METH_O, NULL},
+ { "cdiIterator_inqFiletype", _wrap_cdiIterator_inqFiletype, METH_O, NULL},
+ { "cdiIterator_inqTsteptype", _wrap_cdiIterator_inqTsteptype, METH_O, NULL},
+ { "cdiIterator_inqVariableName", _wrap_cdiIterator_inqVariableName, METH_O, NULL},
+ { "cdiIterator_inqGridId", _wrap_cdiIterator_inqGridId, METH_O, NULL},
+ { "cdiIterator_readField", _wrap_cdiIterator_readField, METH_VARARGS, NULL},
+ { "cdiIterator_readFieldF", _wrap_cdiIterator_readFieldF, METH_VARARGS, NULL},
+ { "cdiGribIterator_clone", _wrap_cdiGribIterator_clone, METH_O, NULL},
+ { "cdiGribIterator_delete", _wrap_cdiGribIterator_delete, METH_O, NULL},
+ { "cdiGribIterator_getLong", _wrap_cdiGribIterator_getLong, METH_VARARGS, NULL},
+ { "cdiGribIterator_getDouble", _wrap_cdiGribIterator_getDouble, METH_VARARGS, NULL},
+ { "cdiGribIterator_getLength", _wrap_cdiGribIterator_getLength, METH_VARARGS, NULL},
+ { "cdiGribIterator_getString", _wrap_cdiGribIterator_getString, METH_VARARGS, NULL},
+ { "cdiGribIterator_getSize", _wrap_cdiGribIterator_getSize, METH_VARARGS, NULL},
+ { "cdiGribIterator_getLongArray", _wrap_cdiGribIterator_getLongArray, METH_VARARGS, NULL},
+ { "cdiGribIterator_getDoubleArray", _wrap_cdiGribIterator_getDoubleArray, METH_VARARGS, NULL},
+ { "cdiGribIterator_inqEdition", _wrap_cdiGribIterator_inqEdition, METH_O, NULL},
+ { "cdiGribIterator_inqLongValue", _wrap_cdiGribIterator_inqLongValue, METH_VARARGS, NULL},
+ { "cdiGribIterator_inqLongDefaultValue", _wrap_cdiGribIterator_inqLongDefaultValue, METH_VARARGS, NULL},
+ { "cdiGribIterator_inqDoubleValue", _wrap_cdiGribIterator_inqDoubleValue, METH_VARARGS, NULL},
+ { "cdiGribIterator_inqDoubleDefaultValue", _wrap_cdiGribIterator_inqDoubleDefaultValue, METH_VARARGS, NULL},
+ { "cdiGribIterator_inqStringValue", _wrap_cdiGribIterator_inqStringValue, METH_VARARGS, NULL},
+ { "vlistCreate", _wrap_vlistCreate, METH_NOARGS, NULL},
+ { "vlistDestroy", _wrap_vlistDestroy, METH_O, NULL},
+ { "vlistDuplicate", _wrap_vlistDuplicate, METH_O, NULL},
+ { "vlistCopy", _wrap_vlistCopy, METH_VARARGS, NULL},
+ { "vlistCopyFlag", _wrap_vlistCopyFlag, METH_VARARGS, NULL},
+ { "vlistClearFlag", _wrap_vlistClearFlag, METH_O, NULL},
+ { "vlistCat", _wrap_vlistCat, METH_VARARGS, NULL},
+ { "vlistMerge", _wrap_vlistMerge, METH_VARARGS, NULL},
+ { "vlistPrint", _wrap_vlistPrint, METH_O, NULL},
+ { "vlistNumber", _wrap_vlistNumber, METH_O, NULL},
+ { "vlistNvars", _wrap_vlistNvars, METH_O, NULL},
+ { "vlistNgrids", _wrap_vlistNgrids, METH_O, NULL},
+ { "vlistNzaxis", _wrap_vlistNzaxis, METH_O, NULL},
+ { "vlistNsubtypes", _wrap_vlistNsubtypes, METH_O, NULL},
+ { "vlistDefNtsteps", _wrap_vlistDefNtsteps, METH_VARARGS, NULL},
+ { "vlistNtsteps", _wrap_vlistNtsteps, METH_O, NULL},
+ { "vlistGridsizeMax", _wrap_vlistGridsizeMax, METH_O, NULL},
+ { "vlistGrid", _wrap_vlistGrid, METH_VARARGS, NULL},
+ { "vlistGridIndex", _wrap_vlistGridIndex, METH_VARARGS, NULL},
+ { "vlistChangeGridIndex", _wrap_vlistChangeGridIndex, METH_VARARGS, NULL},
+ { "vlistChangeGrid", _wrap_vlistChangeGrid, METH_VARARGS, NULL},
+ { "vlistZaxis", _wrap_vlistZaxis, METH_VARARGS, NULL},
+ { "vlistZaxisIndex", _wrap_vlistZaxisIndex, METH_VARARGS, NULL},
+ { "vlistChangeZaxisIndex", _wrap_vlistChangeZaxisIndex, METH_VARARGS, NULL},
+ { "vlistChangeZaxis", _wrap_vlistChangeZaxis, METH_VARARGS, NULL},
+ { "vlistNrecs", _wrap_vlistNrecs, METH_O, NULL},
+ { "vlistSubtype", _wrap_vlistSubtype, METH_VARARGS, NULL},
+ { "vlistSubtypeIndex", _wrap_vlistSubtypeIndex, METH_VARARGS, NULL},
+ { "vlistDefTaxis", _wrap_vlistDefTaxis, METH_VARARGS, NULL},
+ { "vlistInqTaxis", _wrap_vlistInqTaxis, METH_O, NULL},
+ { "vlistDefTable", _wrap_vlistDefTable, METH_VARARGS, NULL},
+ { "vlistInqTable", _wrap_vlistInqTable, METH_O, NULL},
+ { "vlistDefInstitut", _wrap_vlistDefInstitut, METH_VARARGS, NULL},
+ { "vlistInqInstitut", _wrap_vlistInqInstitut, METH_O, NULL},
+ { "vlistDefModel", _wrap_vlistDefModel, METH_VARARGS, NULL},
+ { "vlistInqModel", _wrap_vlistInqModel, METH_O, NULL},
+ { "vlistDefVarTiles", _wrap_vlistDefVarTiles, METH_VARARGS, NULL},
+ { "vlistDefVar", _wrap_vlistDefVar, METH_VARARGS, NULL},
+ { "vlistChangeVarGrid", _wrap_vlistChangeVarGrid, METH_VARARGS, NULL},
+ { "vlistChangeVarZaxis", _wrap_vlistChangeVarZaxis, METH_VARARGS, NULL},
+ { "vlistInqVar", _wrap_vlistInqVar, METH_VARARGS, NULL},
+ { "vlistInqVarGrid", _wrap_vlistInqVarGrid, METH_VARARGS, NULL},
+ { "vlistInqVarZaxis", _wrap_vlistInqVarZaxis, METH_VARARGS, NULL},
+ { "vlistInqVarID", _wrap_vlistInqVarID, METH_VARARGS, NULL},
+ { "vlistDefVarTimetype", _wrap_vlistDefVarTimetype, METH_VARARGS, NULL},
+ { "vlistInqVarTimetype", _wrap_vlistInqVarTimetype, METH_VARARGS, NULL},
+ { "vlistDefVarTsteptype", _wrap_vlistDefVarTsteptype, METH_VARARGS, NULL},
+ { "vlistInqVarTsteptype", _wrap_vlistInqVarTsteptype, METH_VARARGS, NULL},
+ { "vlistDefVarCompType", _wrap_vlistDefVarCompType, METH_VARARGS, NULL},
+ { "vlistInqVarCompType", _wrap_vlistInqVarCompType, METH_VARARGS, NULL},
+ { "vlistDefVarCompLevel", _wrap_vlistDefVarCompLevel, METH_VARARGS, NULL},
+ { "vlistInqVarCompLevel", _wrap_vlistInqVarCompLevel, METH_VARARGS, NULL},
+ { "vlistDefVarParam", _wrap_vlistDefVarParam, METH_VARARGS, NULL},
+ { "vlistInqVarParam", _wrap_vlistInqVarParam, METH_VARARGS, NULL},
+ { "vlistDefVarCode", _wrap_vlistDefVarCode, METH_VARARGS, NULL},
+ { "vlistInqVarCode", _wrap_vlistInqVarCode, METH_VARARGS, NULL},
+ { "vlistDefVarDatatype", _wrap_vlistDefVarDatatype, METH_VARARGS, NULL},
+ { "vlistInqVarDatatype", _wrap_vlistInqVarDatatype, METH_VARARGS, NULL},
+ { "vlistDefVarChunkType", _wrap_vlistDefVarChunkType, METH_VARARGS, NULL},
+ { "vlistInqVarChunkType", _wrap_vlistInqVarChunkType, METH_VARARGS, NULL},
+ { "vlistDefVarXYZ", _wrap_vlistDefVarXYZ, METH_VARARGS, NULL},
+ { "vlistInqVarXYZ", _wrap_vlistInqVarXYZ, METH_VARARGS, NULL},
+ { "vlistInqVarNumber", _wrap_vlistInqVarNumber, METH_VARARGS, NULL},
+ { "vlistDefVarInstitut", _wrap_vlistDefVarInstitut, METH_VARARGS, NULL},
+ { "vlistInqVarInstitut", _wrap_vlistInqVarInstitut, METH_VARARGS, NULL},
+ { "vlistDefVarModel", _wrap_vlistDefVarModel, METH_VARARGS, NULL},
+ { "vlistInqVarModel", _wrap_vlistInqVarModel, METH_VARARGS, NULL},
+ { "vlistDefVarTable", _wrap_vlistDefVarTable, METH_VARARGS, NULL},
+ { "vlistInqVarTable", _wrap_vlistInqVarTable, METH_VARARGS, NULL},
+ { "vlistDefVarName", _wrap_vlistDefVarName, METH_VARARGS, NULL},
+ { "vlistInqVarName", _wrap_vlistInqVarName, METH_VARARGS, NULL},
+ { "vlistCopyVarName", _wrap_vlistCopyVarName, METH_VARARGS, NULL},
+ { "vlistDefVarStdname", _wrap_vlistDefVarStdname, METH_VARARGS, NULL},
+ { "vlistInqVarStdname", _wrap_vlistInqVarStdname, METH_VARARGS, NULL},
+ { "vlistDefVarLongname", _wrap_vlistDefVarLongname, METH_VARARGS, NULL},
+ { "vlistInqVarLongname", _wrap_vlistInqVarLongname, METH_VARARGS, NULL},
+ { "vlistDefVarUnits", _wrap_vlistDefVarUnits, METH_VARARGS, NULL},
+ { "vlistInqVarUnits", _wrap_vlistInqVarUnits, METH_VARARGS, NULL},
+ { "vlistDefVarMissval", _wrap_vlistDefVarMissval, METH_VARARGS, NULL},
+ { "vlistInqVarMissval", _wrap_vlistInqVarMissval, METH_VARARGS, NULL},
+ { "vlistDefVarExtra", _wrap_vlistDefVarExtra, METH_VARARGS, NULL},
+ { "vlistInqVarExtra", _wrap_vlistInqVarExtra, METH_VARARGS, NULL},
+ { "vlistDefVarScalefactor", _wrap_vlistDefVarScalefactor, METH_VARARGS, NULL},
+ { "vlistInqVarScalefactor", _wrap_vlistInqVarScalefactor, METH_VARARGS, NULL},
+ { "vlistDefVarAddoffset", _wrap_vlistDefVarAddoffset, METH_VARARGS, NULL},
+ { "vlistInqVarAddoffset", _wrap_vlistInqVarAddoffset, METH_VARARGS, NULL},
+ { "vlistDefVarTimave", _wrap_vlistDefVarTimave, METH_VARARGS, NULL},
+ { "vlistInqVarTimave", _wrap_vlistInqVarTimave, METH_VARARGS, NULL},
+ { "vlistInqVarSize", _wrap_vlistInqVarSize, METH_VARARGS, NULL},
+ { "vlistDefIndex", _wrap_vlistDefIndex, METH_VARARGS, NULL},
+ { "vlistInqIndex", _wrap_vlistInqIndex, METH_VARARGS, NULL},
+ { "vlistDefFlag", _wrap_vlistDefFlag, METH_VARARGS, NULL},
+ { "vlistInqFlag", _wrap_vlistInqFlag, METH_VARARGS, NULL},
+ { "vlistFindVar", _wrap_vlistFindVar, METH_VARARGS, NULL},
+ { "vlistFindLevel", _wrap_vlistFindLevel, METH_VARARGS, NULL},
+ { "vlistMergedVar", _wrap_vlistMergedVar, METH_VARARGS, NULL},
+ { "vlistMergedLevel", _wrap_vlistMergedLevel, METH_VARARGS, NULL},
+ { "cdiClearAdditionalKeys", _wrap_cdiClearAdditionalKeys, METH_NOARGS, NULL},
+ { "cdiDefAdditionalKey", _wrap_cdiDefAdditionalKey, METH_O, NULL},
+ { "vlistDefVarIntKey", _wrap_vlistDefVarIntKey, METH_VARARGS, NULL},
+ { "vlistDefVarDblKey", _wrap_vlistDefVarDblKey, METH_VARARGS, NULL},
+ { "vlistHasVarKey", _wrap_vlistHasVarKey, METH_VARARGS, NULL},
+ { "vlistInqVarDblKey", _wrap_vlistInqVarDblKey, METH_VARARGS, NULL},
+ { "vlistInqVarIntKey", _wrap_vlistInqVarIntKey, METH_VARARGS, NULL},
+ { "cdiInqNatts", _wrap_cdiInqNatts, METH_VARARGS, NULL},
+ { "cdiInqAtt", _wrap_cdiInqAtt, METH_VARARGS, NULL},
+ { "cdiDelAtt", _wrap_cdiDelAtt, METH_VARARGS, NULL},
+ { "cdiCopyAtts", _wrap_cdiCopyAtts, METH_VARARGS, NULL},
+ { "cdiDefAttInt", _wrap_cdiDefAttInt, METH_VARARGS, NULL},
+ { "cdiDefAttFlt", _wrap_cdiDefAttFlt, METH_VARARGS, NULL},
+ { "cdiDefAttTxt", _wrap_cdiDefAttTxt, METH_VARARGS, NULL},
+ { "cdiInqAttInt", _wrap_cdiInqAttInt, METH_VARARGS, NULL},
+ { "cdiInqAttFlt", _wrap_cdiInqAttFlt, METH_VARARGS, NULL},
+ { "cdiInqAttTxt", _wrap_cdiInqAttTxt, METH_VARARGS, NULL},
+ { "gridName", _wrap_gridName, METH_VARARGS, NULL},
+ { "gridNamePtr", _wrap_gridNamePtr, METH_O, NULL},
+ { "gridCompress", _wrap_gridCompress, METH_O, NULL},
+ { "gridDefMaskGME", _wrap_gridDefMaskGME, METH_VARARGS, NULL},
+ { "gridInqMaskGME", _wrap_gridInqMaskGME, METH_VARARGS, NULL},
+ { "gridDefMask", _wrap_gridDefMask, METH_VARARGS, NULL},
+ { "gridInqMask", _wrap_gridInqMask, METH_VARARGS, NULL},
+ { "gridCreate", _wrap_gridCreate, METH_VARARGS, NULL},
+ { "gridDestroy", _wrap_gridDestroy, METH_O, NULL},
+ { "gridDuplicate", _wrap_gridDuplicate, METH_O, NULL},
+ { "gridDefProj", _wrap_gridDefProj, METH_VARARGS, NULL},
+ { "gridInqProj", _wrap_gridInqProj, METH_O, NULL},
+ { "gridInqProjType", _wrap_gridInqProjType, METH_O, NULL},
+ { "gridInqType", _wrap_gridInqType, METH_O, NULL},
+ { "gridInqSize", _wrap_gridInqSize, METH_O, NULL},
+ { "gridDefXsize", _wrap_gridDefXsize, METH_VARARGS, NULL},
+ { "gridInqXsize", _wrap_gridInqXsize, METH_O, NULL},
+ { "gridDefYsize", _wrap_gridDefYsize, METH_VARARGS, NULL},
+ { "gridInqYsize", _wrap_gridInqYsize, METH_O, NULL},
+ { "gridDefNP", _wrap_gridDefNP, METH_VARARGS, NULL},
+ { "gridInqNP", _wrap_gridInqNP, METH_O, NULL},
+ { "gridDefXvals", _wrap_gridDefXvals, METH_VARARGS, NULL},
+ { "gridInqXvals", _wrap_gridInqXvals, METH_VARARGS, NULL},
+ { "gridInqXvalsPart", _wrap_gridInqXvalsPart, METH_VARARGS, NULL},
+ { "gridInqXIsc", _wrap_gridInqXIsc, METH_O, NULL},
+ { "gridInqXCvals", _wrap_gridInqXCvals, METH_VARARGS, NULL},
+ { "gridDefYvals", _wrap_gridDefYvals, METH_VARARGS, NULL},
+ { "gridInqYvals", _wrap_gridInqYvals, METH_VARARGS, NULL},
+ { "gridInqYvalsPart", _wrap_gridInqYvalsPart, METH_VARARGS, NULL},
+ { "gridInqYIsc", _wrap_gridInqYIsc, METH_O, NULL},
+ { "gridInqYCvals", _wrap_gridInqYCvals, METH_VARARGS, NULL},
+ { "cdiDefKeyInt", _wrap_cdiDefKeyInt, METH_VARARGS, NULL},
+ { "cdiInqKeyInt", _wrap_cdiInqKeyInt, METH_VARARGS, NULL},
+ { "cdiDefKeyBytes", _wrap_cdiDefKeyBytes, METH_VARARGS, NULL},
+ { "cdiInqKeyBytes", _wrap_cdiInqKeyBytes, METH_VARARGS, NULL},
+ { "cdiDefKeyString", _wrap_cdiDefKeyString, METH_VARARGS, NULL},
+ { "cdiInqKeyString", _wrap_cdiInqKeyString, METH_VARARGS, NULL},
+ { "cdiInqKeyLen", _wrap_cdiInqKeyLen, METH_VARARGS, NULL},
+ { "cdiCopyKeys", _wrap_cdiCopyKeys, METH_VARARGS, NULL},
+ { "cdiGridDefKeyStr", _wrap_cdiGridDefKeyStr, METH_VARARGS, NULL},
+ { "cdiGridInqKeyStr", _wrap_cdiGridInqKeyStr, METH_VARARGS, NULL},
+ { "cdiZaxisDefKeyStr", _wrap_cdiZaxisDefKeyStr, METH_VARARGS, NULL},
+ { "cdiZaxisInqKeyStr", _wrap_cdiZaxisInqKeyStr, METH_VARARGS, NULL},
+ { "cdiZaxisDefKeyFlt", _wrap_cdiZaxisDefKeyFlt, METH_VARARGS, NULL},
+ { "cdiZaxisInqKeyFlt", _wrap_cdiZaxisInqKeyFlt, METH_VARARGS, NULL},
+ { "gridDefXname", _wrap_gridDefXname, METH_VARARGS, NULL},
+ { "gridInqXname", _wrap_gridInqXname, METH_VARARGS, NULL},
+ { "gridDefXlongname", _wrap_gridDefXlongname, METH_VARARGS, NULL},
+ { "gridInqXlongname", _wrap_gridInqXlongname, METH_VARARGS, NULL},
+ { "gridDefXunits", _wrap_gridDefXunits, METH_VARARGS, NULL},
+ { "gridInqXunits", _wrap_gridInqXunits, METH_VARARGS, NULL},
+ { "gridDefYname", _wrap_gridDefYname, METH_VARARGS, NULL},
+ { "gridInqYname", _wrap_gridInqYname, METH_VARARGS, NULL},
+ { "gridDefYlongname", _wrap_gridDefYlongname, METH_VARARGS, NULL},
+ { "gridInqYlongname", _wrap_gridInqYlongname, METH_VARARGS, NULL},
+ { "gridDefYunits", _wrap_gridDefYunits, METH_VARARGS, NULL},
+ { "gridInqYunits", _wrap_gridInqYunits, METH_VARARGS, NULL},
+ { "gridInqXstdname", _wrap_gridInqXstdname, METH_VARARGS, NULL},
+ { "gridInqYstdname", _wrap_gridInqYstdname, METH_VARARGS, NULL},
+ { "gridDefDatatype", _wrap_gridDefDatatype, METH_VARARGS, NULL},
+ { "gridInqDatatype", _wrap_gridInqDatatype, METH_O, NULL},
+ { "gridInqXval", _wrap_gridInqXval, METH_VARARGS, NULL},
+ { "gridInqYval", _wrap_gridInqYval, METH_VARARGS, NULL},
+ { "gridInqXinc", _wrap_gridInqXinc, METH_O, NULL},
+ { "gridInqYinc", _wrap_gridInqYinc, METH_O, NULL},
+ { "gridIsCircular", _wrap_gridIsCircular, METH_O, NULL},
+ { "gridInqTrunc", _wrap_gridInqTrunc, METH_O, NULL},
+ { "gridDefTrunc", _wrap_gridDefTrunc, METH_VARARGS, NULL},
+ { "gridDefNumber", _wrap_gridDefNumber, METH_VARARGS, NULL},
+ { "gridInqNumber", _wrap_gridInqNumber, METH_O, NULL},
+ { "gridDefPosition", _wrap_gridDefPosition, METH_VARARGS, NULL},
+ { "gridInqPosition", _wrap_gridInqPosition, METH_O, NULL},
+ { "gridDefReference", _wrap_gridDefReference, METH_VARARGS, NULL},
+ { "gridInqReference", _wrap_gridInqReference, METH_VARARGS, NULL},
+ { "gridDefUUID", _wrap_gridDefUUID, METH_VARARGS, NULL},
+ { "gridInqUUID", _wrap_gridInqUUID, METH_VARARGS, NULL},
+ { "gridDefParamRLL", _wrap_gridDefParamRLL, METH_VARARGS, NULL},
+ { "gridInqParamRLL", _wrap_gridInqParamRLL, METH_VARARGS, NULL},
+ { "gridDefParamGME", _wrap_gridDefParamGME, METH_VARARGS, NULL},
+ { "gridInqParamGME", _wrap_gridInqParamGME, METH_VARARGS, NULL},
+ { "gridDefParamLCC", _wrap_gridDefParamLCC, METH_VARARGS, NULL},
+ { "gridInqParamLCC", _wrap_gridInqParamLCC, METH_VARARGS, NULL},
+ { "gridDefParamSTERE", _wrap_gridDefParamSTERE, METH_VARARGS, NULL},
+ { "gridInqParamSTERE", _wrap_gridInqParamSTERE, METH_VARARGS, NULL},
+ { "gridDefArea", _wrap_gridDefArea, METH_VARARGS, NULL},
+ { "gridInqArea", _wrap_gridInqArea, METH_VARARGS, NULL},
+ { "gridHasArea", _wrap_gridHasArea, METH_O, NULL},
+ { "gridDefNvertex", _wrap_gridDefNvertex, METH_VARARGS, NULL},
+ { "gridInqNvertex", _wrap_gridInqNvertex, METH_O, NULL},
+ { "gridDefXbounds", _wrap_gridDefXbounds, METH_VARARGS, NULL},
+ { "gridInqXbounds", _wrap_gridInqXbounds, METH_VARARGS, NULL},
+ { "gridInqXboundsPart", _wrap_gridInqXboundsPart, METH_VARARGS, NULL},
+ { "gridDefYbounds", _wrap_gridDefYbounds, METH_VARARGS, NULL},
+ { "gridInqYbounds", _wrap_gridInqYbounds, METH_VARARGS, NULL},
+ { "gridInqYboundsPart", _wrap_gridInqYboundsPart, METH_VARARGS, NULL},
+ { "gridDefReducedPoints", _wrap_gridDefReducedPoints, METH_VARARGS, NULL},
+ { "gridInqReducedPoints", _wrap_gridInqReducedPoints, METH_VARARGS, NULL},
+ { "gridChangeType", _wrap_gridChangeType, METH_VARARGS, NULL},
+ { "gridDefComplexPacking", _wrap_gridDefComplexPacking, METH_VARARGS, NULL},
+ { "gridInqComplexPacking", _wrap_gridInqComplexPacking, METH_O, NULL},
+ { "gridDefScanningMode", _wrap_gridDefScanningMode, METH_VARARGS, NULL},
+ { "gridInqScanningMode", _wrap_gridInqScanningMode, METH_O, NULL},
+ { "zaxisName", _wrap_zaxisName, METH_VARARGS, NULL},
+ { "zaxisNamePtr", _wrap_zaxisNamePtr, METH_O, NULL},
+ { "zaxisCreate", _wrap_zaxisCreate, METH_VARARGS, NULL},
+ { "zaxisDestroy", _wrap_zaxisDestroy, METH_O, NULL},
+ { "zaxisInqType", _wrap_zaxisInqType, METH_O, NULL},
+ { "zaxisInqSize", _wrap_zaxisInqSize, METH_O, NULL},
+ { "zaxisDuplicate", _wrap_zaxisDuplicate, METH_O, NULL},
+ { "zaxisDefLevels", _wrap_zaxisDefLevels, METH_VARARGS, NULL},
+ { "zaxisDefCvals", _wrap_zaxisDefCvals, METH_VARARGS, NULL},
+ { "zaxisInqLevels", _wrap_zaxisInqLevels, METH_VARARGS, NULL},
+ { "zaxisInqCLen", _wrap_zaxisInqCLen, METH_O, NULL},
+ { "zaxisInqCVals", _wrap_zaxisInqCVals, METH_VARARGS, NULL},
+ { "zaxisDefLevel", _wrap_zaxisDefLevel, METH_VARARGS, NULL},
+ { "zaxisInqLevel", _wrap_zaxisInqLevel, METH_VARARGS, NULL},
+ { "zaxisDefNlevRef", _wrap_zaxisDefNlevRef, METH_VARARGS, NULL},
+ { "zaxisInqNlevRef", _wrap_zaxisInqNlevRef, METH_O, NULL},
+ { "zaxisDefNumber", _wrap_zaxisDefNumber, METH_VARARGS, NULL},
+ { "zaxisInqNumber", _wrap_zaxisInqNumber, METH_O, NULL},
+ { "zaxisDefUUID", _wrap_zaxisDefUUID, METH_VARARGS, NULL},
+ { "zaxisInqUUID", _wrap_zaxisInqUUID, METH_VARARGS, NULL},
+ { "zaxisDefName", _wrap_zaxisDefName, METH_VARARGS, NULL},
+ { "zaxisInqName", _wrap_zaxisInqName, METH_VARARGS, NULL},
+ { "zaxisDefLongname", _wrap_zaxisDefLongname, METH_VARARGS, NULL},
+ { "zaxisInqLongname", _wrap_zaxisInqLongname, METH_VARARGS, NULL},
+ { "zaxisDefUnits", _wrap_zaxisDefUnits, METH_VARARGS, NULL},
+ { "zaxisInqUnits", _wrap_zaxisInqUnits, METH_VARARGS, NULL},
+ { "zaxisInqStdname", _wrap_zaxisInqStdname, METH_VARARGS, NULL},
+ { "zaxisDefDatatype", _wrap_zaxisDefDatatype, METH_VARARGS, NULL},
+ { "zaxisInqDatatype", _wrap_zaxisInqDatatype, METH_O, NULL},
+ { "zaxisDefPositive", _wrap_zaxisDefPositive, METH_VARARGS, NULL},
+ { "zaxisInqPositive", _wrap_zaxisInqPositive, METH_O, NULL},
+ { "zaxisDefScalar", _wrap_zaxisDefScalar, METH_O, NULL},
+ { "zaxisInqScalar", _wrap_zaxisInqScalar, METH_O, NULL},
+ { "zaxisDefLtype", _wrap_zaxisDefLtype, METH_VARARGS, NULL},
+ { "zaxisInqLtype", _wrap_zaxisInqLtype, METH_O, NULL},
+ { "zaxisDefLtype2", _wrap_zaxisDefLtype2, METH_VARARGS, NULL},
+ { "zaxisInqLtype2", _wrap_zaxisInqLtype2, METH_O, NULL},
+ { "zaxisDefVct", _wrap_zaxisDefVct, METH_VARARGS, NULL},
+ { "zaxisInqVct", _wrap_zaxisInqVct, METH_VARARGS, NULL},
+ { "zaxisInqVctSize", _wrap_zaxisInqVctSize, METH_O, NULL},
+ { "zaxisInqVctPtr", _wrap_zaxisInqVctPtr, METH_O, NULL},
+ { "zaxisDefLbounds", _wrap_zaxisDefLbounds, METH_VARARGS, NULL},
+ { "zaxisInqLbounds", _wrap_zaxisInqLbounds, METH_VARARGS, NULL},
+ { "zaxisInqLbound", _wrap_zaxisInqLbound, METH_VARARGS, NULL},
+ { "zaxisDefUbounds", _wrap_zaxisDefUbounds, METH_VARARGS, NULL},
+ { "zaxisInqUbounds", _wrap_zaxisInqUbounds, METH_VARARGS, NULL},
+ { "zaxisInqUbound", _wrap_zaxisInqUbound, METH_VARARGS, NULL},
+ { "zaxisDefWeights", _wrap_zaxisDefWeights, METH_VARARGS, NULL},
+ { "zaxisInqWeights", _wrap_zaxisInqWeights, METH_VARARGS, NULL},
+ { "zaxisChangeType", _wrap_zaxisChangeType, METH_VARARGS, NULL},
+ { "taxisCreate", _wrap_taxisCreate, METH_O, NULL},
+ { "taxisDestroy", _wrap_taxisDestroy, METH_O, NULL},
+ { "taxisDuplicate", _wrap_taxisDuplicate, METH_O, NULL},
+ { "taxisCopyTimestep", _wrap_taxisCopyTimestep, METH_VARARGS, NULL},
+ { "taxisDefType", _wrap_taxisDefType, METH_VARARGS, NULL},
+ { "taxisInqType", _wrap_taxisInqType, METH_O, NULL},
+ { "taxisDefVdate", _wrap_taxisDefVdate, METH_VARARGS, NULL},
+ { "taxisDefVtime", _wrap_taxisDefVtime, METH_VARARGS, NULL},
+ { "taxisInqVdate", _wrap_taxisInqVdate, METH_O, NULL},
+ { "taxisInqVtime", _wrap_taxisInqVtime, METH_O, NULL},
+ { "taxisDefRdate", _wrap_taxisDefRdate, METH_VARARGS, NULL},
+ { "taxisDefRtime", _wrap_taxisDefRtime, METH_VARARGS, NULL},
+ { "taxisInqRdate", _wrap_taxisInqRdate, METH_O, NULL},
+ { "taxisInqRtime", _wrap_taxisInqRtime, METH_O, NULL},
+ { "taxisDefFdate", _wrap_taxisDefFdate, METH_VARARGS, NULL},
+ { "taxisDefFtime", _wrap_taxisDefFtime, METH_VARARGS, NULL},
+ { "taxisInqFdate", _wrap_taxisInqFdate, METH_O, NULL},
+ { "taxisInqFtime", _wrap_taxisInqFtime, METH_O, NULL},
+ { "taxisHasBounds", _wrap_taxisHasBounds, METH_O, NULL},
+ { "taxisWithBounds", _wrap_taxisWithBounds, METH_O, NULL},
+ { "taxisDeleteBounds", _wrap_taxisDeleteBounds, METH_O, NULL},
+ { "taxisDefVdateBounds", _wrap_taxisDefVdateBounds, METH_VARARGS, NULL},
+ { "taxisDefVtimeBounds", _wrap_taxisDefVtimeBounds, METH_VARARGS, NULL},
+ { "taxisInqVdateBounds", _wrap_taxisInqVdateBounds, METH_VARARGS, NULL},
+ { "taxisInqVtimeBounds", _wrap_taxisInqVtimeBounds, METH_VARARGS, NULL},
+ { "taxisDefCalendar", _wrap_taxisDefCalendar, METH_VARARGS, NULL},
+ { "taxisInqCalendar", _wrap_taxisInqCalendar, METH_O, NULL},
+ { "taxisDefTunit", _wrap_taxisDefTunit, METH_VARARGS, NULL},
+ { "taxisInqTunit", _wrap_taxisInqTunit, METH_O, NULL},
+ { "taxisDefForecastTunit", _wrap_taxisDefForecastTunit, METH_VARARGS, NULL},
+ { "taxisInqForecastTunit", _wrap_taxisInqForecastTunit, METH_O, NULL},
+ { "taxisDefForecastPeriod", _wrap_taxisDefForecastPeriod, METH_VARARGS, NULL},
+ { "taxisInqForecastPeriod", _wrap_taxisInqForecastPeriod, METH_O, NULL},
+ { "taxisDefNumavg", _wrap_taxisDefNumavg, METH_VARARGS, NULL},
+ { "taxisInqNumavg", _wrap_taxisInqNumavg, METH_O, NULL},
+ { "tunitNamePtr", _wrap_tunitNamePtr, METH_O, NULL},
+ { "institutDef", _wrap_institutDef, METH_VARARGS, NULL},
+ { "institutInq", _wrap_institutInq, METH_VARARGS, NULL},
+ { "institutInqNumber", _wrap_institutInqNumber, METH_NOARGS, NULL},
+ { "institutInqCenter", _wrap_institutInqCenter, METH_O, NULL},
+ { "institutInqSubcenter", _wrap_institutInqSubcenter, METH_O, NULL},
+ { "institutInqNamePtr", _wrap_institutInqNamePtr, METH_O, NULL},
+ { "institutInqLongnamePtr", _wrap_institutInqLongnamePtr, METH_O, NULL},
+ { "modelDef", _wrap_modelDef, METH_VARARGS, NULL},
+ { "modelInq", _wrap_modelInq, METH_VARARGS, NULL},
+ { "modelInqInstitut", _wrap_modelInqInstitut, METH_O, NULL},
+ { "modelInqGribID", _wrap_modelInqGribID, METH_O, NULL},
+ { "modelInqNamePtr", _wrap_modelInqNamePtr, METH_O, NULL},
+ { "tableFWriteC", _wrap_tableFWriteC, METH_VARARGS, NULL},
+ { "tableWrite", _wrap_tableWrite, METH_VARARGS, NULL},
+ { "tableRead", _wrap_tableRead, METH_O, NULL},
+ { "tableDef", _wrap_tableDef, METH_VARARGS, NULL},
+ { "tableInqNamePtr", _wrap_tableInqNamePtr, METH_O, NULL},
+ { "tableInq", _wrap_tableInq, METH_VARARGS, NULL},
+ { "tableInqNumber", _wrap_tableInqNumber, METH_NOARGS, NULL},
+ { "tableInqNum", _wrap_tableInqNum, METH_O, NULL},
+ { "tableInqModel", _wrap_tableInqModel, METH_O, NULL},
+ { "tableInqEntry", _wrap_tableInqEntry, METH_VARARGS, NULL},
+ { "streamDefHistory", _wrap_streamDefHistory, METH_VARARGS, NULL},
+ { "streamInqHistorySize", _wrap_streamInqHistorySize, METH_O, NULL},
+ { "streamInqHistoryString", _wrap_streamInqHistoryString, METH_VARARGS, NULL},
+ { "subtypeCreate", _wrap_subtypeCreate, METH_O, NULL},
+ { "subtypePrint", _wrap_subtypePrint, METH_O, NULL},
+ { "subtypeCompare", _wrap_subtypeCompare, METH_VARARGS, NULL},
+ { "subtypeInqSize", _wrap_subtypeInqSize, METH_O, NULL},
+ { "subtypeInqActiveIndex", _wrap_subtypeInqActiveIndex, METH_O, NULL},
+ { "subtypeDefActiveIndex", _wrap_subtypeDefActiveIndex, METH_VARARGS, NULL},
+ { "keyValuePair", _wrap_keyValuePair, METH_VARARGS, NULL},
+ { "matchAND", _wrap_matchAND, METH_VARARGS, NULL},
+ { "subtypeInqSubEntry", _wrap_subtypeInqSubEntry, METH_VARARGS, NULL},
+ { "subtypeInqTile", _wrap_subtypeInqTile, METH_VARARGS, NULL},
+ { "subtypeInqAttribute", _wrap_subtypeInqAttribute, METH_VARARGS, NULL},
+ { "vlistInqVarSubtype", _wrap_vlistInqVarSubtype, METH_VARARGS, NULL},
+ { "gribapiLibraryVersion", _wrap_gribapiLibraryVersion, METH_VARARGS, NULL},
+ { "gaussianLatitudes", _wrap_gaussianLatitudes, METH_VARARGS, NULL},
+ { NULL, NULL, 0, NULL }
+};
+
+static PyMethodDef SwigMethods_proxydocs[] = {
{ NULL, NULL, 0, NULL }
};
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+static swig_type_info _swigt__p_CdiGribIterator = {"_p_CdiGribIterator", "struct CdiGribIterator *|CdiGribIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CdiIterator = {"_p_CdiIterator", "struct CdiIterator *|CdiIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CdiParam = {"_p_CdiParam", "struct CdiParam *|CdiParam *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_a_10__int = {"_p_a_10__int", "int (*)[10]", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_a_2__int = {"_p_a_2__int", "int (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int64_t = {"_p_int64_t", "int64_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_subtype_query_t = {"_p_subtype_query_t", "subtype_query_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
+ &_swigt__p_CdiGribIterator,
+ &_swigt__p_CdiIterator,
+ &_swigt__p_CdiParam,
+ &_swigt__p_FILE,
+ &_swigt__p_a_10__int,
+ &_swigt__p_a_2__int,
&_swigt__p_char,
&_swigt__p_double,
&_swigt__p_float,
&_swigt__p_int,
+ &_swigt__p_int64_t,
+ &_swigt__p_long,
&_swigt__p_off_t,
+ &_swigt__p_p_char,
+ &_swigt__p_p_p_char,
+ &_swigt__p_size_t,
+ &_swigt__p_subtype_query_t,
+ &_swigt__p_unsigned_char,
};
+static swig_cast_info _swigc__p_CdiGribIterator[] = { {&_swigt__p_CdiGribIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CdiIterator[] = { {&_swigt__p_CdiIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CdiParam[] = { {&_swigt__p_CdiParam, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_a_10__int[] = { {&_swigt__p_a_10__int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_a_2__int[] = { {&_swigt__p_a_2__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int64_t[] = { {&_swigt__p_int64_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_p_char[] = { {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_subtype_query_t[] = { {&_swigt__p_subtype_query_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
+ _swigc__p_CdiGribIterator,
+ _swigc__p_CdiIterator,
+ _swigc__p_CdiParam,
+ _swigc__p_FILE,
+ _swigc__p_a_10__int,
+ _swigc__p_a_2__int,
_swigc__p_char,
_swigc__p_double,
_swigc__p_float,
_swigc__p_int,
+ _swigc__p_int64_t,
+ _swigc__p_long,
_swigc__p_off_t,
+ _swigc__p_p_char,
+ _swigc__p_p_p_char,
+ _swigc__p_size_t,
+ _swigc__p_subtype_query_t,
+ _swigc__p_unsigned_char,
};
@@ -12656,18 +18616,18 @@ static swig_const_info swig_const_table[] = {
#endif
/* -----------------------------------------------------------------------------
* Type initialization:
- * This problem is tough by the requirement that no dynamic
- * memory is used. Also, since swig_type_info structures store pointers to
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
- * to swig_type_info structures, we need some lookup code at initialization.
- * The idea is that swig generates all the structures that are needed.
- * The runtime then collects these partially filled structures.
- * The SWIG_InitializeModule function takes these initial arrays out of
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
- * The generated swig_type_info structures are assigned staticly to an initial
+ * The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
@@ -12677,17 +18637,17 @@ static swig_const_info swig_const_table[] = {
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
- * we find the array of casts associated with the type, and loop through it
+ * we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
- * First off, we lookup the cast->type name to see if it is already loaded.
+ * First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
- * 2) If BOTH types (the one we are adding casting info to, and the
+ * 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
@@ -12711,9 +18671,7 @@ SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
- int found, init;
-
- clientdata = clientdata;
+ int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
@@ -12732,27 +18690,23 @@ SWIG_InitializeModule(void *clientdata) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
- module_head = &swig_module;
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
- found=0;
iter=module_head;
do {
if (iter==&swig_module) {
- found=1;
- break;
+ /* Our module is already in the list, so there's nothing more to do. */
+ return;
}
iter=iter->next;
} while (iter!= module_head);
- /* if the is found in the list, then all is done and we may leave */
- if (found) return;
- /* otherwise we must add out module into the list */
+ /* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
- /* When multiple interpeters are used, a module could have already been initialized in
+ /* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
@@ -12760,7 +18714,7 @@ SWIG_InitializeModule(void *clientdata) {
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
- printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+ printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
@@ -12768,7 +18722,7 @@ SWIG_InitializeModule(void *clientdata) {
swig_cast_info *cast;
#ifdef SWIGRUNTIME_DEBUG
- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
@@ -12843,7 +18797,7 @@ SWIG_InitializeModule(void *clientdata) {
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
@@ -12920,30 +18874,51 @@ extern "C" {
SWIGINTERN PyObject *
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
+#if PY_VERSION_HEX >= 0x03000000
+ return PyUnicode_InternFromString("<Swig global variables>");
+#else
return PyString_FromString("<Swig global variables>");
+#endif
}
SWIGINTERN PyObject *
swig_varlink_str(swig_varlinkobject *v) {
+#if PY_VERSION_HEX >= 0x03000000
+ PyObject *str = PyUnicode_InternFromString("(");
+ PyObject *tail;
+ PyObject *joined;
+ swig_globalvar *var;
+ for (var = v->vars; var; var=var->next) {
+ tail = PyUnicode_FromString(var->name);
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+ if (var->next) {
+ tail = PyUnicode_InternFromString(", ");
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+ }
+ }
+ tail = PyUnicode_InternFromString(")");
+ joined = PyUnicode_Concat(str, tail);
+ Py_DecRef(str);
+ Py_DecRef(tail);
+ str = joined;
+#else
PyObject *str = PyString_FromString("(");
- swig_globalvar *var;
+ swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
}
PyString_ConcatAndDel(&str,PyString_FromString(")"));
+#endif
return str;
}
- SWIGINTERN int
- swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
- PyObject *str = swig_varlink_str(v);
- fprintf(fp,"Swig global variables ");
- fprintf(fp,"%s\n", PyString_AsString(str));
- Py_DECREF(str);
- return 0;
- }
-
SWIGINTERN void
swig_varlink_dealloc(swig_varlinkobject *v) {
swig_globalvar *var = v->vars;
@@ -12967,7 +18942,7 @@ extern "C" {
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
- PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+ PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
@@ -12984,7 +18959,7 @@ extern "C" {
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
- PyErr_SetString(PyExc_NameError,"Unknown C global variable");
+ PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
@@ -12993,19 +18968,22 @@ extern "C" {
swig_varlink_type(void) {
static char varlink__doc__[] = "Swig var link object";
static PyTypeObject varlink_type;
- static int type_init = 0;
+ static int type_init = 0;
if (!type_init) {
- const PyTypeObject tmp
- = {
+ const PyTypeObject tmp = {
+#if PY_VERSION_HEX >= 0x03000000
+ PyVarObject_HEAD_INIT(NULL, 0)
+#else
PyObject_HEAD_INIT(NULL)
- 0, /* Number of items in variable part (ob_size) */
- (char *)"swigvarlink", /* Type name (tp_name) */
- sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
- 0, /* Itemsize (tp_itemsize) */
- (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
- (printfunc) swig_varlink_print, /* Print (tp_print) */
- (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
- (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
+ 0, /* ob_size */
+#endif
+ "swigvarlink", /* tp_name */
+ sizeof(swig_varlinkobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor) swig_varlink_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc) swig_varlink_getattr, /* tp_getattr */
+ (setattrfunc) swig_varlink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) swig_varlink_repr, /* tp_repr */
0, /* tp_as_number */
@@ -13013,7 +18991,7 @@ extern "C" {
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
- (reprfunc)swig_varlink_str, /* tp_str */
+ (reprfunc) swig_varlink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
@@ -13023,19 +19001,24 @@ extern "C" {
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
-#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
-#endif
-#if PY_VERSION_HEX >= 0x02030000
0, /* tp_del */
+ 0, /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x03040000
+ 0, /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
- 0,0,0,0 /* tp_alloc -> tp_next */
+ 0, /* tp_allocs */
+ 0, /* tp_frees */
+ 0, /* tp_maxalloc */
+ 0, /* tp_prev */
+ 0 /* tp_next */
#endif
};
varlink_type = tmp;
- varlink_type.ob_type = &PyType_Type;
type_init = 1;
+ if (PyType_Ready(&varlink_type) < 0)
+ return NULL;
}
return &varlink_type;
}
@@ -13051,14 +19034,14 @@ extern "C" {
}
SWIGINTERN void
- SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
+ SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
- strncpy(gv->name,name,size);
+ memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
@@ -13069,9 +19052,11 @@ extern "C" {
SWIGINTERN PyObject *
SWIG_globals(void) {
- static PyObject *_SWIG_globals = 0;
- if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
- return _SWIG_globals;
+ static PyObject *globals = 0;
+ if (!globals) {
+ globals = SWIG_newvarlink();
+ }
+ return globals;
}
/* -----------------------------------------------------------------------------
@@ -13086,7 +19071,7 @@ extern "C" {
for (i = 0; constants[i].type; ++i) {
switch(constants[i].type) {
case SWIG_PY_POINTER:
- obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
+ obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
break;
case SWIG_PY_BINARY:
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
@@ -13114,7 +19099,9 @@ extern "C" {
size_t i;
for (i = 0; methods[i].ml_name; ++i) {
const char *c = methods[i].ml_doc;
- if (c && (c = strstr(c, "swig_ptr: "))) {
+ if (!c) continue;
+ c = strstr(c, "swig_ptr: ");
+ if (c) {
int j;
swig_const_info *ci = 0;
const char *name = c + 10;
@@ -13126,18 +19113,18 @@ extern "C" {
}
}
if (ci) {
- size_t shift = (ci->ptype) - types;
- swig_type_info *ty = types_initial[shift];
- size_t ldoc = (c - methods[i].ml_doc);
- size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
- char *ndoc = (char*)malloc(ldoc + lptr + 10);
- if (ndoc) {
- char *buff = ndoc;
- void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
- if (ptr) {
- strncpy(buff, methods[i].ml_doc, ldoc);
+ void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
+ if (ptr) {
+ size_t shift = (ci->ptype) - types;
+ swig_type_info *ty = types_initial[shift];
+ size_t ldoc = (c - methods[i].ml_doc);
+ size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
+ char *ndoc = (char*)malloc(ldoc + lptr + 10);
+ if (ndoc) {
+ char *buff = ndoc;
+ memcpy(buff, methods[i].ml_doc, ldoc);
buff += ldoc;
- strncpy(buff, "swig_ptr: ", 10);
+ memcpy(buff, "swig_ptr: ", 10);
buff += 10;
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
methods[i].ml_doc = ndoc;
@@ -13148,6 +19135,64 @@ extern "C" {
}
}
+ /* -----------------------------------------------------------------------------
+ * Method creation and docstring support functions
+ * ----------------------------------------------------------------------------- */
+
+ /* -----------------------------------------------------------------------------
+ * Function to find the method definition with the correct docstring for the
+ * proxy module as opposed to the low-level API
+ * ----------------------------------------------------------------------------- */
+
+ SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
+ /* Find the function in the modified method table */
+ size_t offset = 0;
+ int found = 0;
+ while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
+ if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
+ found = 1;
+ break;
+ }
+ offset++;
+ }
+ /* Use the copy with the modified docstring if available */
+ return found ? &SwigMethods_proxydocs[offset] : NULL;
+ }
+
+ /* -----------------------------------------------------------------------------
+ * Wrapper of PyInstanceMethod_New() used in Python 3
+ * It is exported to the generated module, used for -fastproxy
+ * ----------------------------------------------------------------------------- */
+
+ SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
+ if (PyCFunction_Check(func)) {
+ PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
+ PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
+ if (ml)
+ func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
+ }
+#if PY_VERSION_HEX >= 0x03000000
+ return PyInstanceMethod_New(func);
+#else
+ return PyMethod_New(func, NULL, NULL);
+#endif
+ }
+
+ /* -----------------------------------------------------------------------------
+ * Wrapper of PyStaticMethod_New()
+ * It is exported to the generated module, used for -fastproxy
+ * ----------------------------------------------------------------------------- */
+
+ SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
+ if (PyCFunction_Check(func)) {
+ PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
+ PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
+ if (ml)
+ func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
+ }
+ return PyStaticMethod_New(func);
+ }
+
#ifdef __cplusplus
}
#endif
@@ -13159,87 +19204,224 @@ extern "C" {
#ifdef __cplusplus
extern "C"
#endif
-SWIGEXPORT void SWIG_init(void) {
- PyObject *m, *d;
+
+SWIGEXPORT
+#if PY_VERSION_HEX >= 0x03000000
+PyObject*
+#else
+void
+#endif
+SWIG_init(void) {
+ PyObject *m, *d, *md, *globals;
+
+#if PY_VERSION_HEX >= 0x03000000
+ static struct PyModuleDef SWIG_module = {
+ PyModuleDef_HEAD_INIT,
+ SWIG_name,
+ NULL,
+ -1,
+ SwigMethods,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+ };
+#endif
+
+#if defined(SWIGPYTHON_BUILTIN)
+ static SwigPyClientData SwigPyObject_clientdata = {
+ 0, 0, 0, 0, 0, 0, 0
+ };
+ static PyGetSetDef this_getset_def = {
+ (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
+ };
+ static SwigPyGetSet thisown_getset_closure = {
+ SwigPyObject_own,
+ SwigPyObject_own
+ };
+ static PyGetSetDef thisown_getset_def = {
+ (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
+ };
+ PyTypeObject *builtin_pytype;
+ int builtin_base_count;
+ swig_type_info *builtin_basetype;
+ PyObject *tuple;
+ PyGetSetDescrObject *static_getset;
+ PyTypeObject *metatype;
+ PyTypeObject *swigpyobject;
+ SwigPyClientData *cd;
+ PyObject *public_interface, *public_symbol;
+ PyObject *this_descr;
+ PyObject *thisown_descr;
+ PyObject *self = 0;
+ int i;
+
+ (void)builtin_pytype;
+ (void)builtin_base_count;
+ (void)builtin_basetype;
+ (void)tuple;
+ (void)static_getset;
+ (void)self;
+
+ /* Metaclass is used to implement static member variables */
+ metatype = SwigPyObjectType();
+ assert(metatype);
+#endif
+
+ (void)globals;
+
+ /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
+ SWIG_This();
+ SWIG_Python_TypeCache();
+ SwigPyPacked_type();
+#ifndef SWIGPYTHON_BUILTIN
+ SwigPyObject_type();
+#endif
/* Fix SwigMethods to carry the callback ptrs when needed */
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
- m = Py_InitModule((char *) SWIG_name, SwigMethods);
- d = PyModule_GetDict(m);
+#if PY_VERSION_HEX >= 0x03000000
+ m = PyModule_Create(&SWIG_module);
+#else
+ m = Py_InitModule(SWIG_name, SwigMethods);
+#endif
+
+ md = d = PyModule_GetDict(m);
+ (void)md;
SWIG_InitializeModule(0);
- SWIG_InstallConstants(d,swig_const_table);
+#ifdef SWIGPYTHON_BUILTIN
+ swigpyobject = SwigPyObject_TypeOnce();
+
+ SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
+ assert(SwigPyObject_stype);
+ cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
+ if (!cd) {
+ SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
+ SwigPyObject_clientdata.pytype = swigpyobject;
+ } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
+ PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
+# if PY_VERSION_HEX >= 0x03000000
+ return NULL;
+# else
+ return;
+# endif
+ }
+
+ /* All objects have a 'this' attribute */
+ this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
+ (void)this_descr;
+
+ /* All objects have a 'thisown' attribute */
+ thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
+ (void)thisown_descr;
+
+ public_interface = PyList_New(0);
+ public_symbol = 0;
+ (void)public_symbol;
+ PyDict_SetItemString(md, "__all__", public_interface);
+ Py_DECREF(public_interface);
+ for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
+ SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
+ for (i = 0; swig_const_table[i].name != 0; ++i)
+ SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
+#endif
+
+ SWIG_InstallConstants(d,swig_const_table);
+
+ SWIG_Python_SetConstant(d, "CDI_MAX_NAME",SWIG_From_int((int)(256)));
SWIG_Python_SetConstant(d, "CDI_UNDEFID",SWIG_From_int((int)(-1)));
SWIG_Python_SetConstant(d, "CDI_GLOBAL",SWIG_From_int((int)(-1)));
SWIG_Python_SetConstant(d, "CDI_BIGENDIAN",SWIG_From_int((int)(0)));
SWIG_Python_SetConstant(d, "CDI_LITTLEENDIAN",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_PDPENDIAN",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_REAL",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_COMP",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_BOTH",SWIG_From_int((int)(3)));
SWIG_Python_SetConstant(d, "CDI_NOERR",SWIG_From_int((int)(0)));
+ SWIG_Python_SetConstant(d, "CDI_EEOF",SWIG_From_int((int)(-1)));
+ SWIG_Python_SetConstant(d, "CDI_ETMOF",SWIG_From_int((int)(-9)));
SWIG_Python_SetConstant(d, "CDI_ESYSTEM",SWIG_From_int((int)(-10)));
SWIG_Python_SetConstant(d, "CDI_EINVAL",SWIG_From_int((int)(-20)));
- SWIG_Python_SetConstant(d, "CDI_EUFTYPE",SWIG_From_int((int)(-21)));
- SWIG_Python_SetConstant(d, "CDI_ELIBNAVAIL",SWIG_From_int((int)(-22)));
- SWIG_Python_SetConstant(d, "CDI_EUFSTRUCT",SWIG_From_int((int)(-23)));
- SWIG_Python_SetConstant(d, "CDI_EUNC4",SWIG_From_int((int)(-24)));
- SWIG_Python_SetConstant(d, "FILETYPE_GRB",SWIG_From_int((int)(1)));
- SWIG_Python_SetConstant(d, "FILETYPE_GRB2",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "FILETYPE_NC",SWIG_From_int((int)(3)));
- SWIG_Python_SetConstant(d, "FILETYPE_NC2",SWIG_From_int((int)(4)));
- SWIG_Python_SetConstant(d, "FILETYPE_NC4",SWIG_From_int((int)(5)));
- SWIG_Python_SetConstant(d, "FILETYPE_SRV",SWIG_From_int((int)(6)));
- SWIG_Python_SetConstant(d, "FILETYPE_EXT",SWIG_From_int((int)(7)));
- SWIG_Python_SetConstant(d, "FILETYPE_IEG",SWIG_From_int((int)(8)));
- SWIG_Python_SetConstant(d, "COMPRESS_NONE",SWIG_From_int((int)(0)));
- SWIG_Python_SetConstant(d, "COMPRESS_SZIP",SWIG_From_int((int)(1)));
- SWIG_Python_SetConstant(d, "COMPRESS_GZIP",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "COMPRESS_BZIP2",SWIG_From_int((int)(3)));
- SWIG_Python_SetConstant(d, "COMPRESS_ZIP",SWIG_From_int((int)(4)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK",SWIG_From_int((int)(0)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK1",SWIG_From_int((int)(1)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK2",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK3",SWIG_From_int((int)(3)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK4",SWIG_From_int((int)(4)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK5",SWIG_From_int((int)(5)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK6",SWIG_From_int((int)(6)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK7",SWIG_From_int((int)(7)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK8",SWIG_From_int((int)(8)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK9",SWIG_From_int((int)(9)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK10",SWIG_From_int((int)(10)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK11",SWIG_From_int((int)(11)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK12",SWIG_From_int((int)(12)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK13",SWIG_From_int((int)(13)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK14",SWIG_From_int((int)(14)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK15",SWIG_From_int((int)(15)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK16",SWIG_From_int((int)(16)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK17",SWIG_From_int((int)(17)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK18",SWIG_From_int((int)(18)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK19",SWIG_From_int((int)(19)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK20",SWIG_From_int((int)(20)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK21",SWIG_From_int((int)(21)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK22",SWIG_From_int((int)(22)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK23",SWIG_From_int((int)(23)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK24",SWIG_From_int((int)(24)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK25",SWIG_From_int((int)(25)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK26",SWIG_From_int((int)(26)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK27",SWIG_From_int((int)(27)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK28",SWIG_From_int((int)(28)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK29",SWIG_From_int((int)(29)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK30",SWIG_From_int((int)(30)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK31",SWIG_From_int((int)(31)));
- SWIG_Python_SetConstant(d, "DATATYPE_PACK32",SWIG_From_int((int)(32)));
- SWIG_Python_SetConstant(d, "DATATYPE_FLT32",SWIG_From_int((int)(132)));
- SWIG_Python_SetConstant(d, "DATATYPE_FLT64",SWIG_From_int((int)(164)));
- SWIG_Python_SetConstant(d, "DATATYPE_INT8",SWIG_From_int((int)(208)));
- SWIG_Python_SetConstant(d, "DATATYPE_INT16",SWIG_From_int((int)(216)));
- SWIG_Python_SetConstant(d, "DATATYPE_INT32",SWIG_From_int((int)(232)));
- SWIG_Python_SetConstant(d, "DATATYPE_UINT8",SWIG_From_int((int)(308)));
- SWIG_Python_SetConstant(d, "DATATYPE_UINT16",SWIG_From_int((int)(316)));
- SWIG_Python_SetConstant(d, "DATATYPE_UINT32",SWIG_From_int((int)(332)));
- SWIG_Python_SetConstant(d, "DATATYPE_INT",SWIG_From_int((int)(251)));
- SWIG_Python_SetConstant(d, "DATATYPE_FLT",SWIG_From_int((int)(252)));
- SWIG_Python_SetConstant(d, "DATATYPE_TXT",SWIG_From_int((int)(253)));
+ SWIG_Python_SetConstant(d, "CDI_EISDIR",SWIG_From_int((int)(-21)));
+ SWIG_Python_SetConstant(d, "CDI_EISEMPTY",SWIG_From_int((int)(-22)));
+ SWIG_Python_SetConstant(d, "CDI_EUFTYPE",SWIG_From_int((int)(-23)));
+ SWIG_Python_SetConstant(d, "CDI_ELIBNAVAIL",SWIG_From_int((int)(-24)));
+ SWIG_Python_SetConstant(d, "CDI_EUFSTRUCT",SWIG_From_int((int)(-25)));
+ SWIG_Python_SetConstant(d, "CDI_EUNC4",SWIG_From_int((int)(-26)));
+ SWIG_Python_SetConstant(d, "CDI_EDIMSIZE",SWIG_From_int((int)(-27)));
+ SWIG_Python_SetConstant(d, "CDI_ELIMIT",SWIG_From_int((int)(-99)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_GRB",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_GRB2",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_NC",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_NC2",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_NC4",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_NC4C",SWIG_From_int((int)(6)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_NC5",SWIG_From_int((int)(7)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_SRV",SWIG_From_int((int)(8)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_EXT",SWIG_From_int((int)(9)));
+ SWIG_Python_SetConstant(d, "CDI_FILETYPE_IEG",SWIG_From_int((int)(10)));
+ SWIG_Python_SetConstant(d, "CDI_COMPRESS_NONE",SWIG_From_int((int)(0)));
+ SWIG_Python_SetConstant(d, "CDI_COMPRESS_SZIP",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_COMPRESS_AEC",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_COMPRESS_ZIP",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "CDI_COMPRESS_JPEG",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK",SWIG_From_int((int)(0)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK1",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK2",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK3",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK4",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK5",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK6",SWIG_From_int((int)(6)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK7",SWIG_From_int((int)(7)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK8",SWIG_From_int((int)(8)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK9",SWIG_From_int((int)(9)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK10",SWIG_From_int((int)(10)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK11",SWIG_From_int((int)(11)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK12",SWIG_From_int((int)(12)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK13",SWIG_From_int((int)(13)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK14",SWIG_From_int((int)(14)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK15",SWIG_From_int((int)(15)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK16",SWIG_From_int((int)(16)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK17",SWIG_From_int((int)(17)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK18",SWIG_From_int((int)(18)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK19",SWIG_From_int((int)(19)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK20",SWIG_From_int((int)(20)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK21",SWIG_From_int((int)(21)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK22",SWIG_From_int((int)(22)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK23",SWIG_From_int((int)(23)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK24",SWIG_From_int((int)(24)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK25",SWIG_From_int((int)(25)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK26",SWIG_From_int((int)(26)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK27",SWIG_From_int((int)(27)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK28",SWIG_From_int((int)(28)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK29",SWIG_From_int((int)(29)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK30",SWIG_From_int((int)(30)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK31",SWIG_From_int((int)(31)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_PACK32",SWIG_From_int((int)(32)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_CPX32",SWIG_From_int((int)(64)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_CPX64",SWIG_From_int((int)(128)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_FLT32",SWIG_From_int((int)(132)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_FLT64",SWIG_From_int((int)(164)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_INT8",SWIG_From_int((int)(208)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_INT16",SWIG_From_int((int)(216)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_INT32",SWIG_From_int((int)(232)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_UINT8",SWIG_From_int((int)(308)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_UINT16",SWIG_From_int((int)(316)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_UINT32",SWIG_From_int((int)(332)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_INT",SWIG_From_int((int)(251)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_FLT",SWIG_From_int((int)(252)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_TXT",SWIG_From_int((int)(253)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_CPX",SWIG_From_int((int)(254)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_UCHAR",SWIG_From_int((int)(255)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_LONG",SWIG_From_int((int)(256)));
+ SWIG_Python_SetConstant(d, "CDI_DATATYPE_UINT",SWIG_From_int((int)(257)));
+ SWIG_Python_SetConstant(d, "CDI_CHUNK_AUTO",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CDI_CHUNK_GRID",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CDI_CHUNK_LINES",SWIG_From_int((int)(3)));
SWIG_Python_SetConstant(d, "GRID_GENERIC",SWIG_From_int((int)(1)));
SWIG_Python_SetConstant(d, "GRID_GAUSSIAN",SWIG_From_int((int)(2)));
SWIG_Python_SetConstant(d, "GRID_GAUSSIAN_REDUCED",SWIG_From_int((int)(3)));
@@ -13250,10 +19432,13 @@ SWIGEXPORT void SWIG_init(void) {
SWIG_Python_SetConstant(d, "GRID_TRAJECTORY",SWIG_From_int((int)(8)));
SWIG_Python_SetConstant(d, "GRID_UNSTRUCTURED",SWIG_From_int((int)(9)));
SWIG_Python_SetConstant(d, "GRID_CURVILINEAR",SWIG_From_int((int)(10)));
- SWIG_Python_SetConstant(d, "GRID_LCC",SWIG_From_int((int)(11)));
- SWIG_Python_SetConstant(d, "GRID_LCC2",SWIG_From_int((int)(12)));
- SWIG_Python_SetConstant(d, "GRID_LAEA",SWIG_From_int((int)(13)));
- SWIG_Python_SetConstant(d, "GRID_SINUSOIDAL",SWIG_From_int((int)(14)));
+ SWIG_Python_SetConstant(d, "GRID_PROJECTION",SWIG_From_int((int)(12)));
+ SWIG_Python_SetConstant(d, "GRID_CHARXY",SWIG_From_int((int)(13)));
+ SWIG_Python_SetConstant(d, "CDI_PROJ_RLL",SWIG_From_int((int)(21)));
+ SWIG_Python_SetConstant(d, "CDI_PROJ_LCC",SWIG_From_int((int)(22)));
+ SWIG_Python_SetConstant(d, "CDI_PROJ_LAEA",SWIG_From_int((int)(23)));
+ SWIG_Python_SetConstant(d, "CDI_PROJ_SINU",SWIG_From_int((int)(24)));
+ SWIG_Python_SetConstant(d, "CDI_PROJ_STERE",SWIG_From_int((int)(25)));
SWIG_Python_SetConstant(d, "ZAXIS_SURFACE",SWIG_From_int((int)(0)));
SWIG_Python_SetConstant(d, "ZAXIS_GENERIC",SWIG_From_int((int)(1)));
SWIG_Python_SetConstant(d, "ZAXIS_HYBRID",SWIG_From_int((int)(2)));
@@ -13267,31 +19452,105 @@ SWIGEXPORT void SWIG_init(void) {
SWIG_Python_SetConstant(d, "ZAXIS_ALTITUDE",SWIG_From_int((int)(10)));
SWIG_Python_SetConstant(d, "ZAXIS_SIGMA",SWIG_From_int((int)(11)));
SWIG_Python_SetConstant(d, "ZAXIS_MEANSEA",SWIG_From_int((int)(12)));
+ SWIG_Python_SetConstant(d, "ZAXIS_TOA",SWIG_From_int((int)(13)));
+ SWIG_Python_SetConstant(d, "ZAXIS_SEA_BOTTOM",SWIG_From_int((int)(14)));
+ SWIG_Python_SetConstant(d, "ZAXIS_ATMOSPHERE",SWIG_From_int((int)(15)));
+ SWIG_Python_SetConstant(d, "ZAXIS_CLOUD_BASE",SWIG_From_int((int)(16)));
+ SWIG_Python_SetConstant(d, "ZAXIS_CLOUD_TOP",SWIG_From_int((int)(17)));
+ SWIG_Python_SetConstant(d, "ZAXIS_ISOTHERM_ZERO",SWIG_From_int((int)(18)));
+ SWIG_Python_SetConstant(d, "ZAXIS_SNOW",SWIG_From_int((int)(19)));
+ SWIG_Python_SetConstant(d, "ZAXIS_LAKE_BOTTOM",SWIG_From_int((int)(20)));
+ SWIG_Python_SetConstant(d, "ZAXIS_SEDIMENT_BOTTOM",SWIG_From_int((int)(21)));
+ SWIG_Python_SetConstant(d, "ZAXIS_SEDIMENT_BOTTOM_TA",SWIG_From_int((int)(22)));
+ SWIG_Python_SetConstant(d, "ZAXIS_SEDIMENT_BOTTOM_TW",SWIG_From_int((int)(23)));
+ SWIG_Python_SetConstant(d, "ZAXIS_MIX_LAYER",SWIG_From_int((int)(24)));
+ SWIG_Python_SetConstant(d, "ZAXIS_REFERENCE",SWIG_From_int((int)(25)));
+ SWIG_Python_SetConstant(d, "ZAXIS_CHAR",SWIG_From_int((int)(26)));
+ SWIG_Python_SetConstant(d, "SUBTYPE_TILES",SWIG_From_int((int)(SUBTYPE_TILES)));
+ SWIG_Python_SetConstant(d, "MAX_KV_PAIRS_MATCH",SWIG_From_int((int)(10)));
+ SWIG_Python_SetConstant(d, "TIME_CONSTANT",SWIG_From_int((int)(0)));
+ SWIG_Python_SetConstant(d, "TIME_VARYING",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "TIME_VARIABLE",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "TSTEP_INSTANT",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "TSTEP_AVG",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "TSTEP_ACCUM",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "TSTEP_MAX",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "TSTEP_MIN",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "TSTEP_DIFF",SWIG_From_int((int)(6)));
+ SWIG_Python_SetConstant(d, "TSTEP_RMS",SWIG_From_int((int)(7)));
+ SWIG_Python_SetConstant(d, "TSTEP_SD",SWIG_From_int((int)(8)));
+ SWIG_Python_SetConstant(d, "TSTEP_COV",SWIG_From_int((int)(9)));
+ SWIG_Python_SetConstant(d, "TSTEP_RATIO",SWIG_From_int((int)(10)));
+ SWIG_Python_SetConstant(d, "TSTEP_SUM",SWIG_From_int((int)(11)));
+ SWIG_Python_SetConstant(d, "TSTEP_RANGE",SWIG_From_int((int)(12)));
+ SWIG_Python_SetConstant(d, "TSTEP_INSTANT2",SWIG_From_int((int)(13)));
+ SWIG_Python_SetConstant(d, "TSTEP_INSTANT3",SWIG_From_int((int)(14)));
SWIG_Python_SetConstant(d, "TAXIS_ABSOLUTE",SWIG_From_int((int)(1)));
SWIG_Python_SetConstant(d, "TAXIS_RELATIVE",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "TIME_CONSTANT",SWIG_From_int((int)(1)));
- SWIG_Python_SetConstant(d, "TIME_VARIABLE",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "TAXIS_FORECAST",SWIG_From_int((int)(3)));
SWIG_Python_SetConstant(d, "TUNIT_SECOND",SWIG_From_int((int)(1)));
SWIG_Python_SetConstant(d, "TUNIT_MINUTE",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "TUNIT_HOUR",SWIG_From_int((int)(3)));
- SWIG_Python_SetConstant(d, "TUNIT_DAY",SWIG_From_int((int)(4)));
- SWIG_Python_SetConstant(d, "TUNIT_MONTH",SWIG_From_int((int)(5)));
- SWIG_Python_SetConstant(d, "TUNIT_YEAR",SWIG_From_int((int)(6)));
- SWIG_Python_SetConstant(d, "TUNIT_QUARTER",SWIG_From_int((int)(7)));
+ SWIG_Python_SetConstant(d, "TUNIT_QUARTER",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "TUNIT_30MINUTES",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "TUNIT_HOUR",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "TUNIT_3HOURS",SWIG_From_int((int)(6)));
+ SWIG_Python_SetConstant(d, "TUNIT_6HOURS",SWIG_From_int((int)(7)));
+ SWIG_Python_SetConstant(d, "TUNIT_12HOURS",SWIG_From_int((int)(8)));
+ SWIG_Python_SetConstant(d, "TUNIT_DAY",SWIG_From_int((int)(9)));
+ SWIG_Python_SetConstant(d, "TUNIT_MONTH",SWIG_From_int((int)(10)));
+ SWIG_Python_SetConstant(d, "TUNIT_YEAR",SWIG_From_int((int)(11)));
SWIG_Python_SetConstant(d, "CALENDAR_STANDARD",SWIG_From_int((int)(0)));
- SWIG_Python_SetConstant(d, "CALENDAR_PROLEPTIC",SWIG_From_int((int)(1)));
- SWIG_Python_SetConstant(d, "CALENDAR_360DAYS",SWIG_From_int((int)(2)));
- SWIG_Python_SetConstant(d, "CALENDAR_365DAYS",SWIG_From_int((int)(3)));
- SWIG_Python_SetConstant(d, "CALENDAR_366DAYS",SWIG_From_int((int)(4)));
- SWIG_Python_SetConstant(d, "CALENDAR_NONE",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "CALENDAR_GREGORIAN",SWIG_From_int((int)(1)));
+ SWIG_Python_SetConstant(d, "CALENDAR_PROLEPTIC",SWIG_From_int((int)(2)));
+ SWIG_Python_SetConstant(d, "CALENDAR_360DAYS",SWIG_From_int((int)(3)));
+ SWIG_Python_SetConstant(d, "CALENDAR_365DAYS",SWIG_From_int((int)(4)));
+ SWIG_Python_SetConstant(d, "CALENDAR_366DAYS",SWIG_From_int((int)(5)));
+ SWIG_Python_SetConstant(d, "CALENDAR_NONE",SWIG_From_int((int)(6)));
+ SWIG_Python_SetConstant(d, "CDI_UUID_SIZE",SWIG_From_int((int)(16)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_TABLESVERSION",SWIG_From_int((int)(801)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_LOCALTABLESVERSION",SWIG_From_int((int)(802)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_TYPEOFGENERATINGPROCESS",SWIG_From_int((int)(803)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_PRODUCTDEFINITIONTEMPLATE",SWIG_From_int((int)(804)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_TYPEOFPROCESSEDDATA",SWIG_From_int((int)(805)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_SHAPEOFTHEEARTH",SWIG_From_int((int)(806)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_BACKGROUNDPROCESS",SWIG_From_int((int)(807)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_TYPEOFENSEMBLEFORECAST",SWIG_From_int((int)(808)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_NUMBEROFFORECASTSINENSEMBLE",SWIG_From_int((int)(809)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_PERTURBATIONNUMBER",SWIG_From_int((int)(810)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_CENTRE",SWIG_From_int((int)(811)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_SUBCENTRE",SWIG_From_int((int)(812)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_MPIMTYPE",SWIG_From_int((int)(813)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_MPIMCLASS",SWIG_From_int((int)(814)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_MPIMUSER",SWIG_From_int((int)(815)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_REVSTATUS",SWIG_From_int((int)(816)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_REVNUMBER",SWIG_From_int((int)(817)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_GRIB2LOCALSECTIONNUMBER",SWIG_From_int((int)(818)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_SECTION2PADDINGLENGTH",SWIG_From_int((int)(819)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_SECTION2PADDING",SWIG_From_int((int)(820)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_UVRELATIVETOGRID",SWIG_From_int((int)(821)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_CONSTITUENTTYPE",SWIG_From_int((int)(822)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_XNAME",SWIG_From_int((int)(901)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_XDIMNAME",SWIG_From_int((int)(902)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_XLONGNAME",SWIG_From_int((int)(903)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_XUNITS",SWIG_From_int((int)(904)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_YNAME",SWIG_From_int((int)(911)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_YDIMNAME",SWIG_From_int((int)(912)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_YLONGNAME",SWIG_From_int((int)(913)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_YUNITS",SWIG_From_int((int)(914)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_VDIMNAME",SWIG_From_int((int)(920)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_MAPPING",SWIG_From_int((int)(921)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_MAPNAME",SWIG_From_int((int)(922)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_NAME",SWIG_From_int((int)(941)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_DIMNAME",SWIG_From_int((int)(942)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_LONGNAME",SWIG_From_int((int)(943)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_UNITS",SWIG_From_int((int)(944)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_PSNAME",SWIG_From_int((int)(950)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_P0NAME",SWIG_From_int((int)(951)));
+ SWIG_Python_SetConstant(d, "CDI_KEY_P0VALUE",SWIG_From_int((int)(952)));
+#if PY_VERSION_HEX >= 0x03000000
+ return m;
+#else
+ return;
+#endif
}
-/*
- * Local Variables:
- * c-file-style: "Java"
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * show-trailing-whitespace: t
- * require-trailing-newline: t
- * End:
- */
diff --git a/interfaces/python/testLib.py b/interfaces/python/testLib.py
index 8649a694f..64330700d 100644
--- a/interfaces/python/testLib.py
+++ b/interfaces/python/testLib.py
@@ -4,6 +4,6 @@ streamID = CdiLib.streamOpenRead(ifile)
vlistID = CdiLib.streamInqVlist(streamID)
nvars = CdiLib.vlistNvars(vlistID)
for i in range(0,nvars):
- print CdiLib.vlistInqVarCode(vlistID, i),
+ print(CdiLib.vlistInqVarCode(vlistID, i))
CdiLib.streamClose(streamID)
diff --git a/interfaces/ruby/cdilib_wrap.c b/interfaces/ruby/cdilib_wrap.c
index 45e96a928..90eb7deda 100644
--- a/interfaces/ruby/cdilib_wrap.c
+++ b/interfaces/ruby/cdilib_wrap.c
@@ -1,14 +1,19 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.36
- *
- * This file is not intended to be easily readable and contains a number of
+ * Version 4.0.0
+ *
+ * This file is not intended to be easily readable and contains a number of
* coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
* ----------------------------------------------------------------------------- */
+
+#ifndef SWIGRUBY
#define SWIGRUBY
+#endif
+
+
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
* declarations/attributes, and other compiler dependent labels.
@@ -40,28 +45,28 @@
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
-# define SWIGUNUSED
+# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif
+# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
-# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
@@ -76,9 +81,11 @@
#endif
/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-# ifndef GCC_HASCLASSVISIBILITY
-# define GCC_HASCLASSVISIBILITY
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
# endif
#endif
@@ -104,7 +111,7 @@
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
-# endif
+# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
@@ -117,6 +124,19 @@
# define _SCL_SECURE_NO_DEPRECATE
#endif
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used. So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
/* -----------------------------------------------------------------------------
* This section contains generic SWIG labels for method/variable
@@ -149,28 +169,28 @@
#ifndef SWIGUNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
# define SWIGUNUSED
# endif
# elif defined(__ICC)
-# define SWIGUNUSED __attribute__ ((__unused__))
+# define SWIGUNUSED __attribute__ ((__unused__))
# else
-# define SWIGUNUSED
+# define SWIGUNUSED
# endif
#endif
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
-# endif
+# endif
#endif
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
# define SWIGUNUSEDPARM(p)
# else
-# define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
@@ -185,9 +205,11 @@
#endif
/* exporting methods */
-#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
-# ifndef GCC_HASCLASSVISIBILITY
-# define GCC_HASCLASSVISIBILITY
+#if defined(__GNUC__)
+# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+# ifndef GCC_HASCLASSVISIBILITY
+# define GCC_HASCLASSVISIBILITY
+# endif
# endif
#endif
@@ -213,7 +235,7 @@
# define SWIGSTDCALL __stdcall
# else
# define SWIGSTDCALL
-# endif
+# endif
#endif
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
@@ -226,11 +248,24 @@
# define _SCL_SECURE_NO_DEPRECATE
#endif
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used. So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
/* -----------------------------------------------------------------------------
* swigrun.swg
*
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
* type checking.
* ----------------------------------------------------------------------------- */
@@ -249,11 +284,11 @@
/*
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
- creating a static or dynamic library from the swig runtime code.
- In 99.9% of the cases, swig just needs to declare them as 'static'.
-
- But only do this if is strictly necessary, ie, if you have problems
- with your compiler or so.
+ creating a static or dynamic library from the SWIG runtime code.
+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+ But only do this if strictly necessary, ie, if you have problems
+ with your compiler or suchlike.
*/
#ifndef SWIGRUNTIME
@@ -272,22 +307,23 @@
/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN 0x1
#define SWIG_CAST_NEW_MEMORY 0x2
+#define SWIG_POINTER_NO_NULL 0x4
/* Flags for new pointer objects */
#define SWIG_POINTER_OWN 0x1
-/*
+/*
Flags/methods for returning states.
-
- The swig conversion methods, as ConvertPtr, return and integer
+
+ The SWIG conversion methods, as ConvertPtr, return an integer
that tells if the conversion was successful or not. And if not,
an error code can be returned (see swigerrors.swg for the codes).
-
+
Use the following macros/flags to set or process the returning
states.
-
- In old swig versions, you usually write code as:
+
+ In old versions of SWIG, code such as the following was usually written:
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
// success code
@@ -295,7 +331,7 @@
//fail code
}
- Now you can be more explicit as:
+ Now you can be more explicit:
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
if (SWIG_IsOK(res)) {
@@ -304,7 +340,7 @@
// fail code
}
- that seems to be the same, but now you can also do
+ which is the same really, but now you can also do
Type *ptr;
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -319,28 +355,28 @@
} else {
// fail code
}
-
+
I.e., now SWIG_ConvertPtr can return new objects and you can
identify the case and take care of the deallocation. Of course that
- requires also to SWIG_ConvertPtr to return new result values, as
-
- int SWIG_ConvertPtr(obj, ptr,...) {
- if (<obj is ok>) {
- if (<need new object>) {
- *ptr = <ptr to new allocated object>;
- return SWIG_NEWOBJ;
- } else {
- *ptr = <ptr to old object>;
- return SWIG_OLDOBJ;
- }
- } else {
- return SWIG_BADOBJ;
- }
+ also requires SWIG_ConvertPtr to return new result values, such as
+
+ int SWIG_ConvertPtr(obj, ptr,...) {
+ if (<obj is ok>) {
+ if (<need new object>) {
+ *ptr = <ptr to new allocated object>;
+ return SWIG_NEWOBJ;
+ } else {
+ *ptr = <ptr to old object>;
+ return SWIG_OLDOBJ;
+ }
+ } else {
+ return SWIG_BADOBJ;
+ }
}
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
- swig errors code.
+ SWIG errors code.
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
allows to return the 'cast rank', for example, if you have this
@@ -349,18 +385,17 @@
int fooi(int);
and you call
-
+
food(1) // cast rank '1' (1 -> 1.0)
fooi(1) // cast rank '0'
just use the SWIG_AddCast()/SWIG_CheckState()
+*/
-
- */
-#define SWIG_OK (0)
+#define SWIG_OK (0)
#define SWIG_ERROR (-1)
#define SWIG_IsOK(r) (r >= 0)
-#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT (1 << 8)
@@ -381,7 +416,6 @@
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
-
/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
# ifndef SWIG_TypeRank
@@ -392,20 +426,18 @@
# endif
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
-SWIGINTERNINLINE int SWIG_AddCast(int r) {
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
-SWIGINTERNINLINE int SWIG_CheckState(int r) {
- return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
-# define SWIG_AddCast
+# define SWIG_AddCast(r) (r)
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif
-
-
#include <string.h>
#ifdef __cplusplus
@@ -445,7 +477,7 @@ typedef struct swig_module_info {
void *clientdata; /* Language specific module data */
} swig_module_info;
-/*
+/*
Compare two type names skipping the space characters, therefore
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
@@ -465,18 +497,18 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
/*
Check type equivalence in a name list like <name1>|<name2>|...
- Return 0 if not equal, 1 if equal
+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
-SWIG_TypeEquiv(const char *nb, const char *tb) {
- int equiv = 0;
+SWIG_TypeCmp(const char *nb, const char *tb) {
+ int equiv = 1;
const char* te = tb + strlen(tb);
const char* ne = nb;
- while (!equiv && *ne) {
+ while (equiv != 0 && *ne) {
for (nb = ne; *ne; ++ne) {
if (*ne == '|') break;
}
- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
+ equiv = SWIG_TypeNameComp(nb, ne, tb, te);
if (*ne) ++ne;
}
return equiv;
@@ -484,58 +516,65 @@ SWIG_TypeEquiv(const char *nb, const char *tb) {
/*
Check type equivalence in a name list like <name1>|<name2>|...
- Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+ Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
-SWIG_TypeCompare(const char *nb, const char *tb) {
- int equiv = 0;
- const char* te = tb + strlen(tb);
- const char* ne = nb;
- while (!equiv && *ne) {
- for (nb = ne; *ne; ++ne) {
- if (*ne == '|') break;
- }
- equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
- if (*ne) ++ne;
- }
- return equiv;
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+ return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}
-
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty) \
- if (ty) { \
- swig_cast_info *iter = ty->cast; \
- while (iter) { \
- if (comparison) { \
- if (iter == ty->cast) return iter; \
- /* Move iter to the top of the linked list */ \
- iter->prev->next = iter->next; \
- if (iter->next) \
- iter->next->prev = iter->prev; \
- iter->next = ty->cast; \
- iter->prev = 0; \
- if (ty->cast) ty->cast->prev = iter; \
- ty->cast = iter; \
- return iter; \
- } \
- iter = iter->next; \
- } \
- } \
- return 0
-
/*
Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
- SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (strcmp(iter->type->name, c) == 0) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/*
+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
- SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+ if (ty) {
+ swig_cast_info *iter = ty->cast;
+ while (iter) {
+ if (iter->type == from) {
+ if (iter == ty->cast)
+ return iter;
+ /* Move iter to the top of the linked list */
+ iter->prev->next = iter->next;
+ if (iter->next)
+ iter->next->prev = iter->prev;
+ iter->next = ty->cast;
+ iter->prev = 0;
+ if (ty->cast) ty->cast->prev = iter;
+ ty->cast = iter;
+ return iter;
+ }
+ iter = iter->next;
+ }
+ }
+ return 0;
}
/*
@@ -546,7 +585,7 @@ SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}
-/*
+/*
Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
@@ -590,7 +629,7 @@ SWIG_TypePrettyName(const swig_type_info *type) {
return type->name;
}
-/*
+/*
Set the clientdata field for a type
*/
SWIGRUNTIME void
@@ -598,14 +637,14 @@ SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
swig_cast_info *cast = ti->cast;
/* if (ti->clientdata == clientdata) return; */
ti->clientdata = clientdata;
-
+
while (cast) {
if (!cast->converter) {
swig_type_info *tc = cast->type;
if (!tc->clientdata) {
SWIG_TypeClientData(tc, clientdata);
}
- }
+ }
cast = cast->next;
}
}
@@ -614,31 +653,31 @@ SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
SWIG_TypeClientData(ti, clientdata);
ti->owndata = 1;
}
-
+
/*
Search for a swig_type_info structure only by mangled name
Search is a O(log #types)
-
- We start searching at module start, and finish searching when start == end.
+
+ We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
-SWIG_MangledTypeQueryModule(swig_module_info *start,
- swig_module_info *end,
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
const char *name) {
swig_module_info *iter = start;
do {
if (iter->size) {
- register size_t l = 0;
- register size_t r = iter->size - 1;
+ size_t l = 0;
+ size_t r = iter->size - 1;
do {
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
- register size_t i = (l + r) >> 1;
+ size_t i = (l + r) >> 1;
const char *iname = iter->types[i]->name;
if (iname) {
- register int compare = strcmp(name, iname);
- if (compare == 0) {
+ int compare = strcmp(name, iname);
+ if (compare == 0) {
return iter->types[i];
} else if (compare < 0) {
if (i) {
@@ -663,14 +702,14 @@ SWIG_MangledTypeQueryModule(swig_module_info *start,
Search for a swig_type_info structure for either a mangled name or a human readable name.
It first searches the mangled names of the types, which is a O(log #types)
If a type is not found it then searches the human readable names, which is O(#types).
-
- We start searching at module start, and finish searching when start == end.
+
+ We start searching at module start, and finish searching when start == end.
Note: if start == end at the beginning of the function, we go all the way around
the circular list.
*/
SWIGRUNTIME swig_type_info *
-SWIG_TypeQueryModule(swig_module_info *start,
- swig_module_info *end,
+SWIG_TypeQueryModule(swig_module_info *start,
+ swig_module_info *end,
const char *name) {
/* STEP 1: Search the name field using binary search */
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
@@ -681,7 +720,7 @@ SWIG_TypeQueryModule(swig_module_info *start,
of the str field (the human readable name) */
swig_module_info *iter = start;
do {
- register size_t i = 0;
+ size_t i = 0;
for (; i < iter->size; ++i) {
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
return iter->types[i];
@@ -689,56 +728,56 @@ SWIG_TypeQueryModule(swig_module_info *start,
iter = iter->next;
} while (iter != end);
}
-
+
/* neither found a match */
return 0;
}
-/*
+/*
Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
static const char hex[17] = "0123456789abcdef";
- register const unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ const unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register unsigned char uu = *u;
+ unsigned char uu = *u;
*(c++) = hex[(uu & 0xf0) >> 4];
*(c++) = hex[uu & 0xf];
}
return c;
}
-/*
+/*
Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
- register unsigned char *u = (unsigned char *) ptr;
- register const unsigned char *eu = u + sz;
+ unsigned char *u = (unsigned char *) ptr;
+ const unsigned char *eu = u + sz;
for (; u != eu; ++u) {
- register char d = *(c++);
- register unsigned char uu;
+ char d = *(c++);
+ unsigned char uu;
if ((d >= '0') && (d <= '9'))
- uu = ((d - '0') << 4);
+ uu = (unsigned char)((d - '0') << 4);
else if ((d >= 'a') && (d <= 'f'))
- uu = ((d - ('a'-10)) << 4);
- else
+ uu = (unsigned char)((d - ('a'-10)) << 4);
+ else
return (char *) 0;
d = *(c++);
if ((d >= '0') && (d <= '9'))
- uu |= (d - '0');
+ uu |= (unsigned char)(d - '0');
else if ((d >= 'a') && (d <= 'f'))
- uu |= (d - ('a'-10));
- else
+ uu |= (unsigned char)(d - ('a'-10));
+ else
return (char *) 0;
*u = uu;
}
return c;
}
-/*
+/*
Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
@@ -798,24 +837,33 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
#endif
/* Errors in SWIG */
-#define SWIG_UnknownError -1
-#define SWIG_IOError -2
-#define SWIG_RuntimeError -3
-#define SWIG_IndexError -4
-#define SWIG_TypeError -5
-#define SWIG_DivisionByZero -6
-#define SWIG_OverflowError -7
-#define SWIG_SyntaxError -8
-#define SWIG_ValueError -9
+#define SWIG_UnknownError -1
+#define SWIG_IOError -2
+#define SWIG_RuntimeError -3
+#define SWIG_IndexError -4
+#define SWIG_TypeError -5
+#define SWIG_DivisionByZero -6
+#define SWIG_OverflowError -7
+#define SWIG_SyntaxError -8
+#define SWIG_ValueError -9
#define SWIG_SystemError -10
#define SWIG_AttributeError -11
-#define SWIG_MemoryError -12
+#define SWIG_MemoryError -12
#define SWIG_NullReferenceError -13
#include <ruby.h>
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does. We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
/* Remove global macros defined in Ruby's win32.h */
#ifdef write
# undef write
@@ -823,6 +871,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
#ifdef read
# undef read
#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
@@ -889,6 +946,9 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
#ifndef RSTRUCT_PTR
# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
#endif
+#ifndef RTYPEDDATA_P
+# define RTYPEDDATA_P(x) (TYPE(x) != T_DATA)
+#endif
@@ -965,7 +1025,7 @@ static VALUE _mSWIG = Qnil;
/* Define custom exceptions for errors that do not map to existing Ruby
exceptions. Note this only works for C++ since a global cannot be
- initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/
+ initialized by a function in C. For C, fallback to rb_eRuntimeError.*/
SWIGINTERN VALUE
getNullReferenceError(void) {
@@ -1110,12 +1170,9 @@ void Ruby_Format_OverloadedError(
}
/* -----------------------------------------------------------------------------
- * See the LICENSE file for information on copyright, usage and redistribution
- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
- *
* rubytracking.swg
*
- * This file contains support for tracking mappings from
+ * This file contains support for tracking mappings from
* Ruby objects to C++ objects. This functionality is needed
* to implement mark functions for Ruby's mark and sweep
* garbage collector.
@@ -1125,6 +1182,11 @@ void Ruby_Format_OverloadedError(
extern "C" {
#endif
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
/* Ruby 1.8 actually assumes the first case. */
#if SIZEOF_VOIDP == SIZEOF_LONG
# define SWIG2NUM(v) LONG2NUM((unsigned long)v)
@@ -1136,109 +1198,67 @@ extern "C" {
# error sizeof(void*) is not the same as long or long long
#endif
-
-/* Global Ruby hash table to store Trackings from C/C++
- structs to Ruby Objects.
+/* Global hash table to store Trackings from C/C++
+ structs to Ruby Objects.
*/
-static VALUE swig_ruby_trackings = Qnil;
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ANYARGS) {
+ return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
-/* Global variable that stores a reference to the ruby
- hash table delete function. */
-static ID swig_ruby_hash_delete;
-/* Setup a Ruby hash table to store Trackings */
+/* Setup a hash table to store Trackings */
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
- /* Create a ruby hash table to store Trackings from C++
+ /* Create a hash table to store Trackings from C++
objects to Ruby objects. */
- /* Try to see if some other .so has already created a
+ /* Try to see if some other .so has already created a
tracking hash table, which we keep hidden in an instance var
in the SWIG module.
This is done to allow multiple DSOs to share the same
tracking table.
*/
- ID trackings_id = rb_intern( "@__trackings__" );
+ VALUE trackings_value = Qnil;
+ /* change the variable name so that we can mix modules
+ compiled with older SWIG's - this used to be called "@__trackings__" */
+ ID trackings_id = rb_intern( "@__safetrackings__" );
VALUE verbose = rb_gv_get("VERBOSE");
rb_gv_set("VERBOSE", Qfalse);
- swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
+ trackings_value = rb_ivar_get( _mSWIG, trackings_id );
rb_gv_set("VERBOSE", verbose);
- /* No, it hasn't. Create one ourselves */
- if ( swig_ruby_trackings == Qnil )
- {
- swig_ruby_trackings = rb_hash_new();
- rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
- }
-
- /* Now store a reference to the hash table delete function
- so that we only have to look it up once.*/
- swig_ruby_hash_delete = rb_intern("delete");
-}
-
-/* Get a Ruby number to reference a pointer */
-SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
- /* We cast the pointer to an unsigned long
- and then store a reference to it using
- a Ruby number object. */
-
- /* Convert the pointer to a Ruby number */
- return SWIG2NUM(ptr);
-}
-
-/* Get a Ruby number to reference an object */
-SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
- /* We cast the object to an unsigned long
- and then store a reference to it using
- a Ruby number object. */
-
- /* Convert the Object to a Ruby number */
- return SWIG2NUM(object);
-}
-
-/* Get a Ruby object from a previously stored reference */
-SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
- /* The provided Ruby number object is a reference
- to the Ruby object we want.*/
+ /* The trick here is that we have to store the hash table
+ pointer in a Ruby variable. We do not want Ruby's GC to
+ treat this pointer as a Ruby object, so we convert it to
+ a Ruby numeric value. */
+ if (trackings_value == Qnil) {
+ /* No, it hasn't. Create one ourselves */
+ swig_ruby_trackings = st_init_numtable();
+ rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+ } else {
+ swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+ }
- /* Convert the Ruby number to a Ruby object */
- return NUM2SWIG(reference);
+ rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
}
/* Add a Tracking from a C/C++ struct to a Ruby object */
SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
- /* In a Ruby hash table we store the pointer and
- the associated Ruby object. The trick here is
- that we cannot store the Ruby object directly - if
- we do then it cannot be garbage collected. So
- instead we typecast it as a unsigned long and
- convert it to a Ruby number object.*/
-
- /* Get a reference to the pointer as a Ruby number */
- VALUE key = SWIG_RubyPtrToReference(ptr);
-
- /* Get a reference to the Ruby object as a Ruby number */
- VALUE value = SWIG_RubyObjectToReference(object);
-
/* Store the mapping to the global hash table. */
- rb_hash_aset(swig_ruby_trackings, key, value);
+ st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
}
/* Get the Ruby object that owns the specified C/C++ struct */
SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
- /* Get a reference to the pointer as a Ruby number */
- VALUE key = SWIG_RubyPtrToReference(ptr);
-
/* Now lookup the value stored in the global hash table */
- VALUE value = rb_hash_aref(swig_ruby_trackings, key);
-
- if (value == Qnil) {
- /* No object exists - return nil. */
+ VALUE value;
+
+ if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+ return value;
+ } else {
return Qnil;
}
- else {
- /* Convert this value to Ruby object */
- return SWIG_RubyReferenceToObject(value);
- }
}
/* Remove a Tracking from a C/C++ struct to a Ruby object. It
@@ -1246,25 +1266,37 @@ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
since the same memory address may be reused later to create
a new object. */
SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
- /* Get a reference to the pointer as a Ruby number */
- VALUE key = SWIG_RubyPtrToReference(ptr);
-
- /* Delete the object from the hash table by calling Ruby's
- do this we need to call the Hash.delete method.*/
- rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
+ /* Delete the object from the hash table */
+ st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
}
/* This is a helper method that unlinks a Ruby object from its
underlying C++ object. This is needed if the lifetime of the
- Ruby object is longer than the C++ object */
+ Ruby object is longer than the C++ object. */
SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
VALUE object = SWIG_RubyInstanceFor(ptr);
if (object != Qnil) {
+ // object might have the T_ZOMBIE type, but that's just
+ // because the GC has flagged it as such for a deferred
+ // destruction. Until then, it's still a T_DATA object.
DATA_PTR(object) = 0;
}
}
+/* This is a helper method that iterates over all the trackings
+ passing the C++ object pointer and its related Ruby object
+ to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
+ (*meth)(ptr, obj);
+ return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+ st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
+}
#ifdef __cplusplus
}
@@ -1308,9 +1340,6 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
/* -----------------------------------------------------------------------------
- * See the LICENSE file for information on copyright, usage and redistribution
- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
- *
* rubyrun.swg
*
* This file contains the runtime support for Ruby modules
@@ -1326,7 +1355,7 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
-#define swig_owntype ruby_owntype
+#define swig_owntype swig_ruby_owntype
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
@@ -1347,14 +1376,14 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
/* Runtime API */
-#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
+#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
/* Error manipulation */
#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
-#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
+#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
#define SWIG_fail goto fail
@@ -1409,7 +1438,7 @@ static ID swig_call_id = 0;
++swig_virtual_calls;
# define SWIG_RELEASE_STACK --swig_virtual_calls;
# define Ruby_DirectorTypeMismatchException(x) \
- rb_raise( rb_eTypeError, x ); return c_result;
+ rb_raise( rb_eTypeError, "%s", x ); return c_result;
static unsigned int swig_virtual_calls = 0;
@@ -1463,14 +1492,13 @@ SWIG_Ruby_InitRuntime(void)
SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info *type)
{
- VALUE klass;
char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
sprintf(klass_name, "TYPE%s", type->name);
if (NIL_P(_cSWIG_Pointer)) {
_cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
}
- klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+ rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
free((void *) klass_name);
}
@@ -1484,10 +1512,11 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
swig_class *sklass;
VALUE klass;
VALUE obj;
-
+
if (!ptr)
return Qnil;
-
+
+ assert(type);
if (type->clientdata) {
sklass = (swig_class *) type->clientdata;
@@ -1495,13 +1524,13 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
track = sklass->trackObjects;
if (track) {
obj = SWIG_RubyInstanceFor(ptr);
-
+
/* Check the object's type and make sure it has the correct type.
It might not in cases where methods do things like
downcast methods. */
if (obj != Qnil) {
VALUE value = rb_iv_get(obj, "@__swigtype__");
- char* type_name = RSTRING_PTR(value);
+ const char* type_name = RSTRING_PTR(value);
if (strcmp(type->name, type_name) == 0) {
return obj;
@@ -1527,7 +1556,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
obj = Data_Wrap_Struct(klass, 0, 0, ptr);
}
rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
-
+
return obj;
}
@@ -1551,22 +1580,24 @@ SWIG_Ruby_MangleStr(VALUE obj)
}
/* Acquire a pointer value */
-typedef void (*ruby_owntype)(void*);
-
-SWIGRUNTIME ruby_owntype
-SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
- if (obj) {
- ruby_owntype oldown = RDATA(obj)->dfree;
- RDATA(obj)->dfree = own;
- return oldown;
- } else {
- return 0;
+typedef struct {
+ void (*datafree)(void *);
+ int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+ swig_ruby_owntype oldown = {0, 0};
+ if (TYPE(obj) == T_DATA && !RTYPEDDATA_P(obj)) {
+ oldown.datafree = RDATA(obj)->dfree;
+ RDATA(obj)->dfree = own.datafree;
}
+ return oldown;
}
/* Convert a pointer value */
SWIGRUNTIME int
-SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
{
char *c;
swig_cast_info *tc;
@@ -1574,16 +1605,20 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
/* Grab the pointer */
if (NIL_P(obj)) {
- *ptr = 0;
- return SWIG_OK;
+ if (ptr)
+ *ptr = 0;
+ return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
} else {
- if (TYPE(obj) != T_DATA) {
+ if (TYPE(obj) != T_DATA || (TYPE(obj) == T_DATA && RTYPEDDATA_P(obj))) {
return SWIG_ERROR;
}
Data_Get_Struct(obj, void, vptr);
}
- if (own) *own = RDATA(obj)->dfree;
+ if (own) {
+ own->datafree = RDATA(obj)->dfree;
+ own->own = 0;
+ }
/* Check to see if the input object is giving up ownership
of the underlying C struct or C++ object. If so then we
@@ -1618,8 +1653,6 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
/* The object has already been deleted */
return SWIG_ObjectPreviouslyDeletedError;
}
- *ptr = vptr;
- return SWIG_OK;
}
}
if ((c = SWIG_MangleStr(obj)) == NULL) {
@@ -1629,12 +1662,23 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
if (!tc) {
return SWIG_ERROR;
} else {
- int newmemory = 0;
- *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
+ if (ptr) {
+ if (tc->type == ty) {
+ *ptr = vptr;
+ } else {
+ int newmemory = 0;
+ *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+ if (newmemory == SWIG_CAST_NEW_MEMORY) {
+ assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+ if (own)
+ own->own = own->own | SWIG_CAST_NEW_MEMORY;
+ }
+ }
+ }
}
} else {
- *ptr = vptr;
+ if (ptr)
+ *ptr = vptr;
}
return SWIG_OK;
@@ -1660,7 +1704,7 @@ SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
return rb_str_new2(result);
}
-/* Convert a packed value value */
+/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
swig_cast_info *tc;
@@ -1683,7 +1727,7 @@ SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
}
SWIGRUNTIME swig_module_info *
-SWIG_Ruby_GetModule(void)
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
{
VALUE pointer;
swig_module_info *ret = 0;
@@ -1723,7 +1767,7 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
SWIGINTERN
int SWIG_Ruby_isCallable( VALUE proc )
{
- if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
+ if ( rb_respond_to( proc, swig_call_id ) )
return 1;
return 0;
}
@@ -1736,7 +1780,7 @@ int SWIG_Ruby_isCallable( VALUE proc )
SWIGINTERN
int SWIG_Ruby_arity( VALUE proc, int minimal )
{
- if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
+ if ( rb_respond_to( proc, swig_arity_id ) )
{
VALUE num = rb_funcall( proc, swig_arity_id, 0 );
int arity = NUM2INT(num);
@@ -1762,13 +1806,26 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
/* -------- TYPES TABLE (BEGIN) -------- */
-#define SWIGTYPE_p_char swig_types[0]
-#define SWIGTYPE_p_double swig_types[1]
-#define SWIGTYPE_p_float swig_types[2]
-#define SWIGTYPE_p_int swig_types[3]
-#define SWIGTYPE_p_off_t swig_types[4]
-static swig_type_info *swig_types[6];
-static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
+#define SWIGTYPE_p_CdiGribIterator swig_types[0]
+#define SWIGTYPE_p_CdiIterator swig_types[1]
+#define SWIGTYPE_p_CdiParam swig_types[2]
+#define SWIGTYPE_p_FILE swig_types[3]
+#define SWIGTYPE_p_a_10__int swig_types[4]
+#define SWIGTYPE_p_a_2__int swig_types[5]
+#define SWIGTYPE_p_char swig_types[6]
+#define SWIGTYPE_p_double swig_types[7]
+#define SWIGTYPE_p_float swig_types[8]
+#define SWIGTYPE_p_int swig_types[9]
+#define SWIGTYPE_p_int64_t swig_types[10]
+#define SWIGTYPE_p_long swig_types[11]
+#define SWIGTYPE_p_off_t swig_types[12]
+#define SWIGTYPE_p_p_char swig_types[13]
+#define SWIGTYPE_p_p_p_char swig_types[14]
+#define SWIGTYPE_p_size_t swig_types[15]
+#define SWIGTYPE_p_subtype_query_t swig_types[16]
+#define SWIGTYPE_p_unsigned_char swig_types[17]
+static swig_type_info *swig_types[19];
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
@@ -1783,7 +1840,7 @@ static VALUE mCdiLib;
#define SWIG_RUBY_THREAD_END_BLOCK
-#define SWIGVERSION 0x010336
+#define SWIGVERSION 0x040000
#define SWIG_VERSION SWIGVERSION
@@ -1821,7 +1878,7 @@ SWIG_ruby_failed(void)
}
-/*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/usr/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
{
VALUE obj = args[0];
@@ -1903,13 +1960,13 @@ SWIG_FromCharPtr(const char *cptr)
}
-/*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
+/*@SWIG:/usr/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
{
VALUE obj = args[0];
VALUE type = TYPE(obj);
double *res = (double *)(args[1]);
- *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
+ *res = NUM2DBL(obj); (void)type;
return obj;
}
/*@SWIG@*/
@@ -1939,16 +1996,12 @@ SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
{
if (TYPE(obj) == T_STRING) {
- #if defined(StringValuePtr)
char *cstr = StringValuePtr(obj);
- #else
- char *cstr = STR2CSTR(obj);
- #endif
size_t size = RSTRING_LEN(obj) + 1;
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
- *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
+ *cptr = (char *)memcpy(malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
@@ -1975,45 +2028,149 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
-SWIGINTERN VALUE
-_wrap_cdiStringError(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- char *result = 0 ;
- VALUE vresult = Qnil;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long (unsigned long value)
+{
+ return ULONG2NUM(value);
+}
+
+
+#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
+# define SWIG_LONG_LONG_AVAILABLE
+#endif
+
+
+#ifdef SWIG_LONG_LONG_AVAILABLE
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
+{
+ return ULL2NUM(value);
+}
+#endif
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_size_t (size_t value)
+{
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ if (sizeof(size_t) <= sizeof(unsigned long)) {
+#endif
+ return SWIG_From_unsigned_SS_long ((unsigned long)(value));
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ } else {
+ /* assume sizeof(size_t) <= sizeof(unsigned long long) */
+ return SWIG_From_unsigned_SS_long_SS_long ((unsigned long long)(value));
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiStringError", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- result = (char *)cdiStringError(arg1);
- vresult = SWIG_FromCharPtr((const char *)result);
- return vresult;
-fail:
- return Qnil;
+#endif
+}
+
+
+/*@SWIG:/usr/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
+{
+ VALUE obj = args[0];
+ VALUE type = TYPE(obj);
+ unsigned long *res = (unsigned long *)(args[1]);
+ *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+ return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
+{
+ VALUE type = TYPE(obj);
+ if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+ unsigned long v;
+ VALUE a[2];
+ a[0] = obj;
+ a[1] = (VALUE)(&v);
+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
+ }
+ return SWIG_TypeError;
+}
+
+
+#ifdef SWIG_LONG_LONG_AVAILABLE
+/*@SWIG:/usr/share/swig/4.0.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
+{
+ VALUE obj = args[0];
+ VALUE type = TYPE(obj);
+ long long *res = (long long *)(args[1]);
+ *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
+ return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
+{
+ VALUE type = TYPE(obj);
+ if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+ unsigned long long v;
+ VALUE a[2];
+ a[0] = obj;
+ a[1] = (VALUE)(&v);
+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+ if (val) *val = v;
+ return SWIG_OK;
+ }
+ }
+ return SWIG_TypeError;
+}
+#endif
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t (VALUE obj, size_t *val)
+{
+ int res = SWIG_TypeError;
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ if (sizeof(size_t) <= sizeof(unsigned long)) {
+#endif
+ unsigned long v;
+ res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+#ifdef SWIG_LONG_LONG_AVAILABLE
+ } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
+ unsigned long long v;
+ res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+ }
+#endif
+ return res;
}
+static swig_class SwigClassSubtype_query_t;
SWIGINTERN VALUE
-_wrap_cdiDebug(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
+_wrap_subtype_query_t_nAND_set(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDebug", 1, argv[0] ));
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "subtype_query_t *","nAND", 1, self ));
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","nAND", 2, argv[0] ));
}
- arg1 = (int)(val1);
- cdiDebug(arg1);
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->nAND = arg2;
return Qnil;
fail:
return Qnil;
@@ -2021,15 +2178,23 @@ fail:
SWIGINTERN VALUE
-_wrap_cdiLibraryVersion(int argc, VALUE *argv, VALUE self) {
- char *result = 0 ;
+_wrap_subtype_query_t_nAND_get(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int result;
VALUE vresult = Qnil;
if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- result = (char *)cdiLibraryVersion();
- vresult = SWIG_FromCharPtr((const char *)result);
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "subtype_query_t *","nAND", 1, self ));
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ result = (int) ((arg1)->nAND);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -2037,32 +2202,133 @@ fail:
SWIGINTERN VALUE
-_wrap_cdiPrintVersion(int argc, VALUE *argv, VALUE self) {
- if ((argc < 0) || (argc > 0)) {
+_wrap_subtype_query_t_key_value_pairs_set(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ int (*arg2)[10] ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "subtype_query_t *","key_value_pairs", 1, self ));
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_a_10__int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int [2][10]","key_value_pairs", 2, argv[0] ));
+ }
+ arg2 = (int (*)[10])(argp2);
+ {
+ if (arg2) {
+ size_t ii = 0;
+ for (; ii < (size_t)2; ++ii) {
+ if (arg2[ii]) {
+ size_t jj = 0;
+ for (; jj < (size_t)10; ++jj) arg1->key_value_pairs[ii][jj] = arg2[ii][jj];
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""key_value_pairs""' of type '""int [2][10]""'");
+ }
+ }
+ } else {
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""key_value_pairs""' of type '""int [2][10]""'");
+ }
+ }
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_subtype_query_t_key_value_pairs_get(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t *arg1 = (subtype_query_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int (*result)[10] = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- cdiPrintVersion();
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_subtype_query_t, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "subtype_query_t *","key_value_pairs", 1, self ));
+ }
+ arg1 = (subtype_query_t *)(argp1);
+ result = (int (*)[10])(int (*)[10]) ((arg1)->key_value_pairs);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_10__int, 0 | 0 );
+ return vresult;
+fail:
return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_subtype_query_t_allocate(VALUE self)
+#else
+_wrap_subtype_query_t_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_subtype_query_t);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+ rb_obj_call_init(vresult, argc, argv);
+#endif
+ return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_subtype_query_t(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t *result = 0 ;
+
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ result = (subtype_query_t *)calloc(1, sizeof(subtype_query_t));
+ DATA_PTR(self) = result;
+ return self;
fail:
return Qnil;
}
+SWIGINTERN void
+free_subtype_query_t(void *self) {
+ subtype_query_t *arg1 = (subtype_query_t *)self;
+ free((char *) arg1);
+}
+
+static swig_class SwigClassCdiParam;
+
SWIGINTERN VALUE
-_wrap_cdiDefMissval(int argc, VALUE *argv, VALUE self) {
- double arg1 ;
- double val1 ;
- int ecode1 = 0 ;
+_wrap_CdiParam_discipline_set(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ int arg2 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_double(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","cdiDefMissval", 1, argv[0] ));
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","discipline", 1, self ));
+ }
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","discipline", 2, argv[0] ));
}
- arg1 = (double)(val1);
- cdiDefMissval(arg1);
+ arg2 = (int)(val2);
+ if (arg1) (arg1)->discipline = arg2;
return Qnil;
fail:
return Qnil;
@@ -2070,15 +2336,23 @@ fail:
SWIGINTERN VALUE
-_wrap_cdiInqMissval(int argc, VALUE *argv, VALUE self) {
- double result;
+_wrap_CdiParam_discipline_get(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int result;
VALUE vresult = Qnil;
if ((argc < 0) || (argc > 0)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- result = (double)cdiInqMissval();
- vresult = SWIG_From_double((double)(result));
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","discipline", 1, self ));
+ }
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->discipline);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -2086,149 +2360,185 @@ fail:
SWIGINTERN VALUE
-_wrap_cdiDefGlobal(int argc, VALUE *argv, VALUE self) {
- char *arg1 = (char *) 0 ;
+_wrap_CdiParam_category_set(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiDefGlobal", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","category", 1, self ));
}
- arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefGlobal", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","category", 2, argv[0] ));
}
arg2 = (int)(val2);
- cdiDefGlobal((char const *)arg1,arg2);
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ if (arg1) (arg1)->category = arg2;
return Qnil;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamOpenRead(int argc, VALUE *argv, VALUE self) {
- char *arg1 = (char *) 0 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+_wrap_CdiParam_category_get(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenRead", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","category", 1, self ));
}
- arg1 = (char *)(buf1);
- result = (int)streamOpenRead((char const *)arg1);
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->category);
vresult = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return vresult;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamOpenWrite(int argc, VALUE *argv, VALUE self) {
- char *arg1 = (char *) 0 ;
+_wrap_CdiParam_number_set(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenWrite", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","number", 1, self ));
}
- arg1 = (char *)(buf1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ arg1 = (struct CdiParam *)(argp1);
+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamOpenWrite", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","number", 2, argv[0] ));
}
arg2 = (int)(val2);
- result = (int)streamOpenWrite((char const *)arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
- return vresult;
+ if (arg1) (arg1)->number = arg2;
+ return Qnil;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamOpenAppend(int argc, VALUE *argv, VALUE self) {
- char *arg1 = (char *) 0 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+_wrap_CdiParam_number_get(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *arg1 = (struct CdiParam *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CdiParam, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenAppend", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct CdiParam *","number", 1, self ));
}
- arg1 = (char *)(buf1);
- result = (int)streamOpenAppend((char const *)arg1);
+ arg1 = (struct CdiParam *)(argp1);
+ result = (int) ((arg1)->number);
vresult = SWIG_From_int((int)(result));
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return vresult;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamClose(int argc, VALUE *argv, VALUE self) {
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_CdiParam_allocate(VALUE self)
+#else
+_wrap_CdiParam_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CdiParam);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+ rb_obj_call_init(vresult, argc, argv);
+#endif
+ return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_CdiParam(int argc, VALUE *argv, VALUE self) {
+ struct CdiParam *result = 0 ;
+
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ result = (struct CdiParam *)calloc(1, sizeof(struct CdiParam));
+ DATA_PTR(self) = result;
+ return self;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN void
+free_CdiParam(void *self) {
+ struct CdiParam *arg1 = (struct CdiParam *)self;
+ free((char *) arg1);
+}
+
+SWIGINTERN VALUE
+_wrap_cdiReset(int argc, VALUE *argv, VALUE self) {
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ cdiReset();
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiStringError(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamClose", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiStringError", 1, argv[0] ));
}
arg1 = (int)(val1);
- streamClose(arg1);
- return Qnil;
+ result = (char *)cdiStringError(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamSync(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiDebug(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -2238,10 +2548,10 @@ _wrap_streamSync(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamSync", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDebug", 1, argv[0] ));
}
arg1 = (int)(val1);
- streamSync(arg1);
+ cdiDebug(arg1);
return Qnil;
fail:
return Qnil;
@@ -2249,28 +2559,27 @@ fail:
SWIGINTERN VALUE
-_wrap_streamDefVlist(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiLibraryVersion(int argc, VALUE *argv, VALUE self) {
+ char *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefVlist", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefVlist", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- streamDefVlist(arg1,arg2);
+ result = (char *)cdiLibraryVersion();
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiPrintVersion(int argc, VALUE *argv, VALUE self) {
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ cdiPrintVersion();
return Qnil;
fail:
return Qnil;
@@ -2278,7 +2587,7 @@ fail:
SWIGINTERN VALUE
-_wrap_streamInqVlist(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiHaveFiletype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -2290,10 +2599,10 @@ _wrap_streamInqVlist(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqVlist", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiHaveFiletype", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)streamInqVlist(arg1);
+ result = (int)cdiHaveFiletype(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -2302,75 +2611,99 @@ fail:
SWIGINTERN VALUE
-_wrap_streamInqFiletype(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
+_wrap_cdiDefMissval(int argc, VALUE *argv, VALUE self) {
+ double arg1 ;
+ double val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ ecode1 = SWIG_AsVal_double(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqFiletype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","cdiDefMissval", 1, argv[0] ));
}
- arg1 = (int)(val1);
- result = (int)streamInqFiletype(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg1 = (double)(val1);
+ cdiDefMissval(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamDefByteorder(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+_wrap_cdiInqMissval(int argc, VALUE *argv, VALUE self) {
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ result = (double)cdiInqMissval();
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqGridMissval(int argc, VALUE *argv, VALUE self) {
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ result = (double)cdiInqGridMissval();
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefGlobal(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int arg2 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefByteorder", 1, argv[0] ));
- }
- arg1 = (int)(val1);
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiDefGlobal", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefByteorder", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefGlobal", 2, argv[1] ));
}
arg2 = (int)(val2);
- streamDefByteorder(arg1,arg2);
+ cdiDefGlobal((char const *)arg1,arg2);
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamInqByteorder(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
+_wrap_namespaceNew(int argc, VALUE *argv, VALUE self) {
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqByteorder", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- result = (int)streamInqByteorder(arg1);
+ result = (int)namespaceNew();
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -2379,28 +2712,20 @@ fail:
SWIGINTERN VALUE
-_wrap_streamDefZtype(int argc, VALUE *argv, VALUE self) {
+_wrap_namespaceSetActive(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefZtype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","namespaceSetActive", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefZtype", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- streamDefZtype(arg1,arg2);
+ namespaceSetActive(arg1);
return Qnil;
fail:
return Qnil;
@@ -2408,139 +2733,160 @@ fail:
SWIGINTERN VALUE
-_wrap_streamDefZlevel(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_namespaceGetActive(int argc, VALUE *argv, VALUE self) {
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefZlevel", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefZlevel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- streamDefZlevel(arg1,arg2);
- return Qnil;
+ result = (int)namespaceGetActive();
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamInqZtype(int argc, VALUE *argv, VALUE self) {
+_wrap_namespaceDelete(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqZtype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","namespaceDelete", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)streamInqZtype(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ namespaceDelete(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamInqZlevel(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiParamToString(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqZlevel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiParamToString", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)streamInqZlevel(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","cdiParamToString", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiParamToString", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ cdiParamToString(arg1,arg2,arg3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamDefTimestep(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiDecodeParam(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefTimestep", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDecodeParam", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefTimestep", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)streamDefTimestep(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiDecodeParam", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiDecodeParam", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiDecodeParam", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ cdiDecodeParam(arg1,arg2,arg3,arg4);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamInqTimestep(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiEncodeParam(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqTimestep", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiEncodeParam", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamInqTimestep", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiEncodeParam", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)streamInqTimestep(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiEncodeParam", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)cdiEncodeParam(arg1,arg2,arg3);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -2549,47 +2895,90 @@ fail:
SWIGINTERN VALUE
-_wrap_streamFilename(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- char *result = 0 ;
- VALUE vresult = Qnil;
+_wrap_cdiDecodeDate(int argc, VALUE *argv, VALUE self) {
+ int64_t arg1 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilename", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- result = (char *)streamFilename(arg1);
- vresult = SWIG_FromCharPtr((const char *)result);
- return vresult;
+ {
+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int64_t","cdiDecodeDate", 1, argv[0] ));
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","cdiDecodeDate", 1, argv[0]));
+ } else {
+ arg1 = *((int64_t *)(argp1));
+ }
+ }
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiDecodeDate", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiDecodeDate", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiDecodeDate", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ cdiDecodeDate(arg1,arg2,arg3,arg4);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamFilesuffix(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiEncodeDate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- char *result = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int64_t result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilesuffix", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiEncodeDate", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (char *)streamFilesuffix(arg1);
- vresult = SWIG_FromCharPtr((const char *)result);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiEncodeDate", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiEncodeDate", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = cdiEncodeDate(arg1,arg2,arg3);
+ vresult = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
@@ -2597,22 +2986,83 @@ fail:
SWIGINTERN VALUE
-_wrap_streamNtsteps(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiDecodeTime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int val1 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDecodeTime", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiDecodeTime", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiDecodeTime", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiDecodeTime", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ cdiDecodeTime(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiEncodeTime(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamNtsteps", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiEncodeTime", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)streamNtsteps(arg1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiEncodeTime", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiEncodeTime", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)cdiEncodeTime(arg1,arg2,arg3);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -2621,68 +3071,165 @@ fail:
SWIGINTERN VALUE
-_wrap_streamNvals(int argc, VALUE *argv, VALUE self) {
+_wrap_cdiGetFiletype(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiGetFiletype", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiGetFiletype", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ result = (int)cdiGetFiletype((char const *)arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamOpenRead(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenRead", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ result = (int)streamOpenRead((char const *)arg1);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamOpenWrite(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int arg2 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenWrite", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamOpenWrite", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)streamOpenWrite((char const *)arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamOpenAppend(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenAppend", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ result = (int)streamOpenAppend((char const *)arg1);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamClose(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- off_t result;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamNvals", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamClose", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = streamNvals(arg1);
- vresult = SWIG_NewPointerObj((off_t *)memcpy((off_t *)malloc(sizeof(off_t)),&result,sizeof(off_t)), SWIGTYPE_p_off_t, SWIG_POINTER_OWN | 0 );
- return vresult;
+ streamClose(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamReadVar(int argc, VALUE *argv, VALUE self) {
+_wrap_streamSync(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- double *arg3 = (double *) 0 ;
- int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamSync", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVar", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","streamReadVar", 3, argv[2] ));
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","streamReadVar", 4, argv[3] ));
- }
- arg4 = (int *)(argp4);
- streamReadVar(arg1,arg2,arg3,arg4);
+ streamSync(arg1);
return Qnil;
fail:
return Qnil;
@@ -2690,44 +3237,28 @@ fail:
SWIGINTERN VALUE
-_wrap_streamWriteVar(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefNumWorker(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- double *arg3 = (double *) 0 ;
- int arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefNumWorker", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVar", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefNumWorker", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","streamWriteVar", 3, argv[2] ));
- }
- arg3 = (double *)(argp3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","streamWriteVar", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- streamWriteVar(arg1,arg2,(double const *)arg3,arg4);
+ streamDefNumWorker(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -2735,52 +3266,28 @@ fail:
SWIGINTERN VALUE
-_wrap_streamReadVarSlice(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefVlist(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- int arg3 ;
- double *arg4 = (double *) 0 ;
- int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefVlist", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefVlist", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","streamReadVarSlice", 4, argv[3] ));
- }
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","streamReadVarSlice", 5, argv[4] ));
- }
- arg5 = (int *)(argp5);
- streamReadVarSlice(arg1,arg2,arg3,arg4,arg5);
+ streamDefVlist(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -2788,163 +3295,76 @@ fail:
SWIGINTERN VALUE
-_wrap_streamWriteVarSlice(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqVlist(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
- double *arg4 = (double *) 0 ;
- int arg5 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- int val5 ;
- int ecode5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqVlist", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double const *","streamWriteVarSlice", 4, argv[3] ));
- }
- arg4 = (double *)(argp4);
- ecode5 = SWIG_AsVal_int(argv[4], &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 5, argv[4] ));
- }
- arg5 = (int)(val5);
- streamWriteVarSlice(arg1,arg2,arg3,(double const *)arg4,arg5);
- return Qnil;
+ result = (int)streamInqVlist(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamInqRecord(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqFiletype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
- int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqRecord", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqFiletype", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqRecord", 2, argv[1] ));
- }
- arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","streamInqRecord", 3, argv[2] ));
- }
- arg3 = (int *)(argp3);
- streamInqRecord(arg1,arg2,arg3);
- return Qnil;
+ result = (int)streamInqFiletype(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamDefRecord(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefByteorder(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefRecord", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefByteorder", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefRecord", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefByteorder", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamDefRecord", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- streamDefRecord(arg1,arg2,arg3);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_streamReadRecord(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- double *arg2 = (double *) 0 ;
- int *arg3 = (int *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
-
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadRecord", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","streamReadRecord", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","streamReadRecord", 3, argv[2] ));
- }
- arg3 = (int *)(argp3);
- streamReadRecord(arg1,arg2,arg3);
+ streamDefByteorder(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -2952,44 +3372,31 @@ fail:
SWIGINTERN VALUE
-_wrap_streamWriteRecord(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqByteorder(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteRecord", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqByteorder", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","streamWriteRecord", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteRecord", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- streamWriteRecord(arg1,(double const *)arg2,arg3);
- return Qnil;
+ result = (int)streamInqByteorder(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_streamCopyRecord(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefCompType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -3002,15 +3409,15 @@ _wrap_streamCopyRecord(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamCopyRecord", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefCompType", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamCopyRecord", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefCompType", 2, argv[1] ));
}
arg2 = (int)(val2);
- streamCopyRecord(arg1,arg2);
+ streamDefCompType(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -3018,51 +3425,22 @@ fail:
SWIGINTERN VALUE
-_wrap_streamInqGinfo(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqCompType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
- float *arg3 = (float *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqGinfo", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqCompType", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqGinfo", 2, argv[1] ));
- }
- arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float *","streamInqGinfo", 3, argv[2] ));
- }
- arg3 = (float *)(argp3);
- streamInqGinfo(arg1,arg2,arg3);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_vlistCreate(int argc, VALUE *argv, VALUE self) {
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 0) || (argc > 0)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
- }
- result = (int)vlistCreate();
+ result = (int)streamInqCompType(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -3071,20 +3449,28 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDestroy(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefCompLevel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDestroy", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefCompLevel", 1, argv[0] ));
}
arg1 = (int)(val1);
- vlistDestroy(arg1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefCompLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ streamDefCompLevel(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -3092,7 +3478,7 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDuplicate(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqCompLevel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -3104,10 +3490,10 @@ _wrap_vlistDuplicate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDuplicate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqCompLevel", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistDuplicate(arg1);
+ result = (int)streamInqCompLevel(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -3116,169 +3502,123 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistCopy(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefTimestep(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopy", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefTimestep", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopy", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefTimestep", 2, argv[1] ));
}
arg2 = (int)(val2);
- vlistCopy(arg1,arg2);
- return Qnil;
+ result = (int)streamDefTimestep(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistCopyFlag(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqTimestep(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqTimestep", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamInqTimestep", 2, argv[1] ));
}
arg2 = (int)(val2);
- vlistCopyFlag(arg1,arg2);
- return Qnil;
-fail:
+ result = (int)streamInqTimestep(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistClearFlag(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqCurTimestepID(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistClearFlag", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- vlistClearFlag(arg1);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_vlistCat(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCat", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCat", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- vlistCat(arg1,arg2);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_vlistMerge(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMerge", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqCurTimestepID", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMerge", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- vlistMerge(arg1,arg2);
- return Qnil;
+ result = (int)streamInqCurTimestepID(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistPrint(int argc, VALUE *argv, VALUE self) {
+_wrap_streamFilename(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistPrint", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilename", 1, argv[0] ));
}
arg1 = (int)(val1);
- vlistPrint(arg1);
- return Qnil;
+ result = (char *)streamFilename(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistNvars(int argc, VALUE *argv, VALUE self) {
+_wrap_streamFilesuffix(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ char *result = 0 ;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -3286,11 +3626,11 @@ _wrap_vlistNvars(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNvars", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilesuffix", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistNvars(arg1);
- vresult = SWIG_From_int((int)(result));
+ result = (char *)streamFilesuffix(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
return vresult;
fail:
return Qnil;
@@ -3298,11 +3638,11 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistNgrids(int argc, VALUE *argv, VALUE self) {
+_wrap_streamNvals(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ size_t result;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -3310,11 +3650,11 @@ _wrap_vlistNgrids(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNgrids", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamNvals", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistNgrids(arg1);
- vresult = SWIG_From_int((int)(result));
+ result = streamNvals(arg1);
+ vresult = SWIG_From_size_t((size_t)(result));
return vresult;
fail:
return Qnil;
@@ -3322,7 +3662,7 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistNzaxis(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqNvars(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -3334,10 +3674,10 @@ _wrap_vlistNzaxis(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNzaxis", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqNvars", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistNzaxis(arg1);
+ result = (int)streamInqNvars(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -3346,28 +3686,44 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefNtsteps(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteVar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ double *arg3 ;
+ size_t arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ size_t val4 ;
+ int ecode4 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVar", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVar", 2, argv[1] ));
}
arg2 = (int)(val2);
- vlistDefNtsteps(arg1,arg2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const []","streamWriteVar", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","streamWriteVar", 4, argv[3] ));
+ }
+ arg4 = (size_t)(val4);
+ streamWriteVar(arg1,arg2,(double const (*))arg3,arg4);
return Qnil;
fail:
return Qnil;
@@ -3375,148 +3731,209 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistNtsteps(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteVarF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ float *arg3 ;
+ size_t arg4 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ size_t val4 ;
+ int ecode4 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNtsteps", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarF", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistNtsteps(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_vlistGridsizeMax(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridsizeMax", 1, argv[0] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarF", 2, argv[1] ));
}
- arg1 = (int)(val1);
- result = (int)vlistGridsizeMax(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const []","streamWriteVarF", 3, argv[2] ));
+ }
+ arg3 = (float *)(argp3);
+ ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","streamWriteVarF", 4, argv[3] ));
+ }
+ arg4 = (size_t)(val4);
+ streamWriteVarF(arg1,arg2,(float const (*))arg3,arg4);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistGrid(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ double *arg3 ;
+ size_t *arg4 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGrid", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVar", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGrid", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVar", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistGrid(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double []","streamReadVar", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","streamReadVar", 4, argv[3] ));
+ }
+ arg4 = (size_t *)(argp4);
+ streamReadVar(arg1,arg2,arg3,arg4);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistGridIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVarF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ float *arg3 ;
+ size_t *arg4 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarF", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGridIndex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarF", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistGridIndex(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float []","streamReadVarF", 3, argv[2] ));
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","streamReadVarF", 4, argv[3] ));
+ }
+ arg4 = (size_t *)(argp4);
+ streamReadVarF(arg1,arg2,arg3,arg4);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistChangeGridIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVarPart(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int arg3 ;
+ int arg4 ;
+ size_t arg5 ;
+ void *arg6 = (void *) 0 ;
+ size_t *arg7 = (size_t *) 0 ;
+ int arg8 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
+ int res6 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ int val8 ;
+ int ecode8 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 8) || (argc > 8)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarPart", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarPart", 2, argv[1] ));
}
arg2 = (int)(val2);
ecode3 = SWIG_AsVal_int(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarPart", 3, argv[2] ));
}
arg3 = (int)(val3);
- vlistChangeGridIndex(arg1,arg2,arg3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","streamReadVarPart", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","streamReadVarPart", 5, argv[4] ));
+ }
+ arg5 = (size_t)(val5);
+ res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","streamReadVarPart", 6, argv[5] ));
+ }
+ res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "size_t *","streamReadVarPart", 7, argv[6] ));
+ }
+ arg7 = (size_t *)(argp7);
+ ecode8 = SWIG_AsVal_int(argv[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","streamReadVarPart", 8, argv[7] ));
+ }
+ arg8 = (int)(val8);
+ streamReadVarPart(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
return Qnil;
fail:
return Qnil;
@@ -3524,36 +3941,52 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistChangeGrid(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteVarSlice(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int arg3 ;
+ double *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 2, argv[1] ));
}
arg2 = (int)(val2);
ecode3 = SWIG_AsVal_int(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 3, argv[2] ));
}
arg3 = (int)(val3);
- vlistChangeGrid(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double const []","streamWriteVarSlice", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","streamWriteVarSlice", 5, argv[4] ));
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarSlice(arg1,arg2,arg3,(double const (*))arg4,arg5);
return Qnil;
fail:
return Qnil;
@@ -3561,100 +3994,188 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistZaxis(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteVarSliceF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ int arg3 ;
+ float *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxis", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarSliceF", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxis", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarSliceF", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistZaxis(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteVarSliceF", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const []","streamWriteVarSliceF", 4, argv[3] ));
+ }
+ arg4 = (float *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","streamWriteVarSliceF", 5, argv[4] ));
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarSliceF(arg1,arg2,arg3,(float const (*))arg4,arg5);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistZaxisIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVarSlicePart(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
+ size_t arg6 ;
+ void *arg7 = (void *) 0 ;
+ size_t *arg8 = (size_t *) 0 ;
+ int arg9 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ size_t val6 ;
+ int ecode6 = 0 ;
+ int res7 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ int val9 ;
+ int ecode9 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 9) || (argc > 9)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistZaxisIndex(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ ecode6 = SWIG_AsVal_size_t(argv[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","streamReadVarSlicePart", 6, argv[5] ));
+ }
+ arg6 = (size_t)(val6);
+ res7 = SWIG_ConvertPtr(argv[6],SWIG_as_voidptrptr(&arg7), 0, 0);
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "void *","streamReadVarSlicePart", 7, argv[6] ));
+ }
+ res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "size_t *","streamReadVarSlicePart", 8, argv[7] ));
+ }
+ arg8 = (size_t *)(argp8);
+ ecode9 = SWIG_AsVal_int(argv[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","streamReadVarSlicePart", 9, argv[8] ));
+ }
+ arg9 = (int)(val9);
+ streamReadVarSlicePart(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistChangeZaxisIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVarSlice(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int arg3 ;
+ double *arg4 ;
+ size_t *arg5 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 2, argv[1] ));
}
arg2 = (int)(val2);
ecode3 = SWIG_AsVal_int(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 3, argv[2] ));
}
arg3 = (int)(val3);
- vlistChangeZaxisIndex(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double []","streamReadVarSlice", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "size_t *","streamReadVarSlice", 5, argv[4] ));
+ }
+ arg5 = (size_t *)(argp5);
+ streamReadVarSlice(arg1,arg2,arg3,arg4,arg5);
return Qnil;
fail:
return Qnil;
@@ -3662,36 +4183,52 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistChangeZaxis(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadVarSliceF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int arg3 ;
+ float *arg4 ;
+ size_t *arg5 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarSliceF", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarSliceF", 2, argv[1] ));
}
arg2 = (int)(val2);
ecode3 = SWIG_AsVal_int(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarSliceF", 3, argv[2] ));
}
arg3 = (int)(val3);
- vlistChangeZaxis(arg1,arg2,arg3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float []","streamReadVarSliceF", 4, argv[3] ));
+ }
+ arg4 = (float *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "size_t *","streamReadVarSliceF", 5, argv[4] ));
+ }
+ arg5 = (size_t *)(argp5);
+ streamReadVarSliceF(arg1,arg2,arg3,arg4,arg5);
return Qnil;
fail:
return Qnil;
@@ -3699,52 +4236,89 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistNrecs(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteVarChunk(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ int (*arg3)[2] ;
+ double *arg4 ;
+ size_t arg5 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t val5 ;
+ int ecode5 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNrecs", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarChunk", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistNrecs(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarChunk", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_a_2__int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const [3][2]","streamWriteVarChunk", 3, argv[2] ));
+ }
+ arg3 = (int (*)[2])(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double const []","streamWriteVarChunk", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","streamWriteVarChunk", 5, argv[4] ));
+ }
+ arg5 = (size_t)(val5);
+ streamWriteVarChunk(arg1,arg2,(int const (*)[2])arg3,(double const (*))arg4,arg5);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefTaxis(int argc, VALUE *argv, VALUE self) {
+_wrap_streamDefRecord(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefRecord", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefRecord", 2, argv[1] ));
}
arg2 = (int)(val2);
- vlistDefTaxis(arg1,arg2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamDefRecord", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ streamDefRecord(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -3752,52 +4326,73 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqTaxis(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqRecord(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTaxis", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqRecord", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistInqTaxis(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqRecord", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","streamInqRecord", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ streamInqRecord(arg1,arg2,arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefTable(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteRecord(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ double *arg2 ;
+ size_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTable", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteRecord", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTable", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","streamWriteRecord", 2, argv[1] ));
}
- arg2 = (int)(val2);
- vlistDefTable(arg1,arg2);
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","streamWriteRecord", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ streamWriteRecord(arg1,(double const (*))arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -3805,52 +4400,73 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqTable(int argc, VALUE *argv, VALUE self) {
+_wrap_streamWriteRecordF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ float *arg2 ;
+ size_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTable", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteRecordF", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistInqTable(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float const []","streamWriteRecordF", 2, argv[1] ));
+ }
+ arg2 = (float *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","streamWriteRecordF", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ streamWriteRecordF(arg1,(float const (*))arg2,arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefInstitut(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadRecord(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ double *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadRecord", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","streamReadRecord", 2, argv[1] ));
}
- arg2 = (int)(val2);
- vlistDefInstitut(arg1,arg2);
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","streamReadRecord", 3, argv[2] ));
+ }
+ arg3 = (size_t *)(argp3);
+ streamReadRecord(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -3858,31 +4474,44 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqInstitut(int argc, VALUE *argv, VALUE self) {
+_wrap_streamReadRecordF(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ float *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqInstitut", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadRecordF", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistInqInstitut(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float []","streamReadRecordF", 2, argv[1] ));
+ }
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","streamReadRecordF", 3, argv[2] ));
+ }
+ arg3 = (size_t *)(argp3);
+ streamReadRecordF(arg1,arg2,arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefModel(int argc, VALUE *argv, VALUE self) {
+_wrap_streamCopyRecord(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -3895,15 +4524,15 @@ _wrap_vlistDefModel(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefModel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamCopyRecord", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefModel", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamCopyRecord", 2, argv[1] ));
}
arg2 = (int)(val2);
- vlistDefModel(arg1,arg2);
+ streamCopyRecord(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -3911,71 +4540,95 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqModel(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqGRIBinfo(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int *arg2 = (int *) 0 ;
+ float *arg3 = (float *) 0 ;
+ off_t *arg4 = (off_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqModel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqGRIBinfo", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)vlistInqModel(arg1);
- vresult = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqGRIBinfo", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float *","streamInqGRIBinfo", 3, argv[2] ));
+ }
+ arg3 = (float *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_off_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "off_t *","streamInqGRIBinfo", 4, argv[3] ));
+ }
+ arg4 = (off_t *)(argp4);
+ streamInqGRIBinfo(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiIterator_new(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ CdiIterator *result = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiIterator_new", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ result = (CdiIterator *)cdiIterator_new((char const *)arg1);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return vresult;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVar(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int arg4 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- int result;
+_wrap_cdiIterator_clone(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ CdiIterator *result = 0 ;
VALUE vresult = Qnil;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVar", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVar", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVar", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefVar", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- result = (int)vlistDefVar(arg1,arg2,arg3,arg4);
- vresult = SWIG_From_int((int)(result));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_clone", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (CdiIterator *)cdiIterator_clone(arg1);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
return vresult;
fail:
return Qnil;
@@ -3983,73 +4636,79 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistChangeVarGrid(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_serialize(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistChangeVarGrid(arg1,arg2,arg3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_serialize", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_serialize(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
+fail:
return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiIterator_deserialize(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+ CdiIterator *result = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiIterator_deserialize", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ result = (CdiIterator *)cdiIterator_deserialize((char const *)arg1);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistChangeVarZaxis(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_print(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ FILE *arg2 = (FILE *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistChangeVarZaxis(arg1,arg2,arg3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_print", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FILE, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FILE *","cdiIterator_print", 2, argv[1] ));
+ }
+ arg2 = (FILE *)(argp2);
+ cdiIterator_print(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -4057,52 +4716,20 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVar(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int *arg3 = (int *) 0 ;
- int *arg4 = (int *) 0 ;
- int *arg5 = (int *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
+_wrap_cdiIterator_delete(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVar", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVar", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","vlistInqVar", 3, argv[2] ));
- }
- arg3 = (int *)(argp3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","vlistInqVar", 4, argv[3] ));
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- arg4 = (int *)(argp4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqVar", 5, argv[4] ));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_delete", 1, argv[0] ));
}
- arg5 = (int *)(argp5);
- vlistInqVar(arg1,arg2,arg3,arg4,arg5);
+ arg1 = (CdiIterator *)(argp1);
+ cdiIterator_delete(arg1);
return Qnil;
fail:
return Qnil;
@@ -4110,30 +4737,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarGrid(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_nextField(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarGrid(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_nextField", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_nextField(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4142,31 +4761,23 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarZaxis(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int result;
+_wrap_cdiIterator_inqStartTime(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarZaxis(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqStartTime", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqStartTime(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
return vresult;
fail:
return Qnil;
@@ -4174,31 +4785,23 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarTime(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int result;
+_wrap_cdiIterator_inqEndTime(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTime", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTime", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarTime(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqEndTime", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqEndTime(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
return vresult;
fail:
return Qnil;
@@ -4206,67 +4809,110 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarZtype(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_inqRTime(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarZtype(arg1,arg2,arg3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqRTime", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqRTime(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
+fail:
return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiIterator_inqVTime(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqVTime", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqVTime(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarZtype(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
+_wrap_cdiIterator_inqLevelType(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+ char **arg3 = (char **) 0 ;
+ char **arg4 = (char **) 0 ;
+ char **arg5 = (char **) 0 ;
+ char **arg6 = (char **) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 6) || (argc > 6)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZtype", 1, argv[0] ));
- }
- arg1 = (int)(val1);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqLevelType", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZtype", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiIterator_inqLevelType", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistInqVarZtype(arg1,arg2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char **","cdiIterator_inqLevelType", 3, argv[2] ));
+ }
+ arg3 = (char **)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char **","cdiIterator_inqLevelType", 4, argv[3] ));
+ }
+ arg4 = (char **)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char **","cdiIterator_inqLevelType", 5, argv[4] ));
+ }
+ arg5 = (char **)(argp5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char **","cdiIterator_inqLevelType", 6, argv[5] ));
+ }
+ arg6 = (char **)(argp6);
+ result = (int)cdiIterator_inqLevelType(arg1,arg2,arg3,arg4,arg5,arg6);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4275,67 +4921,94 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarZlevel(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
+_wrap_cdiIterator_inqLevel(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 1, argv[0] ));
- }
- arg1 = (int)(val1);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqLevel", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiIterator_inqLevel", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarZlevel(arg1,arg2,arg3);
- return Qnil;
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","cdiIterator_inqLevel", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","cdiIterator_inqLevel", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ result = (int)cdiIterator_inqLevel(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarZlevel(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_inqLevelUuid(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ unsigned char *arg4 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZlevel", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZlevel", 2, argv[1] ));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqLevelUuid", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiIterator_inqLevelUuid", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiIterator_inqLevelUuid", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned char [16]","cdiIterator_inqLevelUuid", 4, argv[3] ));
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarZlevel(arg1,arg2);
+ arg4 = (unsigned char *)(argp4);
+ result = (int)cdiIterator_inqLevelUuid(arg1,arg2,arg3,arg4);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4344,67 +5017,78 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarCode(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_inqTile(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarCode(arg1,arg2,arg3);
- return Qnil;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqTile", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiIterator_inqTile", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiIterator_inqTile", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiIterator_inqTile(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarCode(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_inqTileCount(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarCode(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqTileCount", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiIterator_inqTileCount", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiIterator_inqTileCount", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiIterator_inqTileCount(arg1,arg2,arg3);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4413,36 +5097,68 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarDatatype(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_inqParam(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ CdiParam result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarDatatype(arg1,arg2,arg3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqParam", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = cdiIterator_inqParam(arg1);
+ vresult = SWIG_NewPointerObj((CdiParam *)memcpy((CdiParam *)calloc(1,sizeof(CdiParam)),&result,sizeof(CdiParam)), SWIGTYPE_p_CdiParam, SWIG_POINTER_OWN | 0 );
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiIterator_inqParamParts(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqParamParts", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","cdiIterator_inqParamParts", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiIterator_inqParamParts", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiIterator_inqParamParts", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ cdiIterator_inqParamParts(arg1,arg2,arg3,arg4);
return Qnil;
fail:
return Qnil;
@@ -4450,30 +5166,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarDatatype(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_inqDatatype(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarDatatype(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqDatatype", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqDatatype(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4482,67 +5190,46 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarInstitut(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_inqFiletype(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarInstitut(arg1,arg2,arg3);
- return Qnil;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqFiletype", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqFiletype(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarInstitut(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_inqTsteptype(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarInstitut(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqTsteptype", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqTsteptype(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4551,67 +5238,46 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarModel(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_inqVariableName(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarModel(arg1,arg2,arg3);
- return Qnil;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqVariableName", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (char *)cdiIterator_inqVariableName(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarModel(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiIterator_inqGridId(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarModel(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_inqGridId", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ result = (int)cdiIterator_inqGridId(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -4620,701 +5286,698 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistDefVarTable(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+_wrap_cdiIterator_readField(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ double *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarTable(arg1,arg2,arg3);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_vlistInqVarTable(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_readField", 1, argv[0] ));
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 2, argv[1] ));
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","cdiIterator_readField", 2, argv[1] ));
}
- arg2 = (int)(val2);
- result = (int)vlistInqVarTable(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","cdiIterator_readField", 3, argv[2] ));
+ }
+ arg3 = (size_t *)(argp3);
+ cdiIterator_readField(arg1,arg2,arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarName(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiIterator_readFieldF(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ float *arg2 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarName", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarName", 2, argv[1] ));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiIterator_readFieldF", 1, argv[0] ));
+ }
+ arg1 = (CdiIterator *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_float, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float []","cdiIterator_readFieldF", 2, argv[1] ));
}
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ arg2 = (float *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarName", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","cdiIterator_readFieldF", 3, argv[2] ));
}
- arg3 = (char *)(buf3);
- vlistDefVarName(arg1,arg2,(char const *)arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg3 = (size_t *)(argp3);
+ cdiIterator_readFieldF(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarName(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_clone(int argc, VALUE *argv, VALUE self) {
+ CdiIterator *arg1 = (CdiIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ CdiGribIterator *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarName", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarName", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarName", 3, argv[2] ));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiIterator *","cdiGribIterator_clone", 1, argv[0] ));
}
- arg3 = (char *)(buf3);
- vlistInqVarName(arg1,arg2,arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ arg1 = (CdiIterator *)(argp1);
+ result = (CdiGribIterator *)cdiGribIterator_clone(arg1);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarLongname(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_delete(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarLongname", 3, argv[2] ));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_delete", 1, argv[0] ));
}
- arg3 = (char *)(buf3);
- vlistDefVarLongname(arg1,arg2,(char const *)arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg1 = (CdiGribIterator *)(argp1);
+ cdiGribIterator_delete(arg1);
return Qnil;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarStdname(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_getLong(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long *arg3 = (long *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getLong", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getLong", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_long, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarStdname", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "long *","cdiGribIterator_getLong", 3, argv[2] ));
}
- arg3 = (char *)(buf3);
- vlistDefVarStdname(arg1,arg2,(char const *)arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ arg3 = (long *)(argp3);
+ result = (int)cdiGribIterator_getLong(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarLongname(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_getDouble(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double *arg3 = (double *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getDouble", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getDouble", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarLongname", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","cdiGribIterator_getDouble", 3, argv[2] ));
}
- arg3 = (char *)(buf3);
- vlistInqVarLongname(arg1,arg2,arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ arg3 = (double *)(argp3);
+ result = (int)cdiGribIterator_getDouble(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarStdname(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_getLength(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getLength", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getLength", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarStdname", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","cdiGribIterator_getLength", 3, argv[2] ));
}
- arg3 = (char *)(buf3);
- vlistInqVarStdname(arg1,arg2,arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ arg3 = (size_t *)(argp3);
+ result = (int)cdiGribIterator_getLength(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarUnits(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
+_wrap_cdiGribIterator_getString(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 2, argv[1] ));
- }
- arg2 = (int)(val2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getString", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getString", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarUnits", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","cdiGribIterator_getString", 3, argv[2] ));
}
arg3 = (char *)(buf3);
- vlistDefVarUnits(arg1,arg2,(char const *)arg3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","cdiGribIterator_getString", 4, argv[3] ));
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getString(arg1,(char const *)arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarUnits(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+_wrap_cdiGribIterator_getSize(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ size_t *arg3 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getSize", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getSize", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_size_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarUnits", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","cdiGribIterator_getSize", 3, argv[2] ));
}
- arg3 = (char *)(buf3);
- vlistInqVarUnits(arg1,arg2,arg3);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ arg3 = (size_t *)(argp3);
+ result = (int)cdiGribIterator_getSize(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarMissval(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- double arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
+_wrap_cdiGribIterator_getLongArray(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long *arg3 = (long *) 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarMissval", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- vlistDefVarMissval(arg1,arg2,arg3);
- return Qnil;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getLongArray", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getLongArray", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_long, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "long *","cdiGribIterator_getLongArray", 3, argv[2] ));
+ }
+ arg3 = (long *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","cdiGribIterator_getLongArray", 4, argv[3] ));
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getLongArray(arg1,(char const *)arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarMissval(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (double)vlistInqVarMissval(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
+_wrap_cdiGribIterator_getDoubleArray(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double *arg3 = (double *) 0 ;
+ size_t *arg4 = (size_t *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_getDoubleArray", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_getDoubleArray", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","cdiGribIterator_getDoubleArray", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_size_t, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","cdiGribIterator_getDoubleArray", 4, argv[3] ));
+ }
+ arg4 = (size_t *)(argp4);
+ result = (int)cdiGribIterator_getDoubleArray(arg1,(char const *)arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarScalefactor(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- double arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
+_wrap_cdiGribIterator_inqEdition(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarScalefactor", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- vlistDefVarScalefactor(arg1,arg2,arg3);
- return Qnil;
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqEdition", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ result = (int)cdiGribIterator_inqEdition(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarScalefactor(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double result;
+_wrap_cdiGribIterator_inqLongValue(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ long result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (double)vlistInqVarScalefactor(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqLongValue", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_inqLongValue", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ result = (long)cdiGribIterator_inqLongValue(arg1,(char const *)arg2);
+ vresult = SWIG_From_long((long)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarAddoffset(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- double arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
+_wrap_cdiGribIterator_inqLongDefaultValue(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ long arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ long val3 ;
int ecode3 = 0 ;
+ long result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqLongDefaultValue", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_inqLongDefaultValue", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_long(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarAddoffset", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","cdiGribIterator_inqLongDefaultValue", 3, argv[2] ));
}
- arg3 = (double)(val3);
- vlistDefVarAddoffset(arg1,arg2,arg3);
- return Qnil;
+ arg3 = (long)(val3);
+ result = (long)cdiGribIterator_inqLongDefaultValue(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_long((long)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarAddoffset(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+_wrap_cdiGribIterator_inqDoubleValue(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
double result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (double)vlistInqVarAddoffset(arg1,arg2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqDoubleValue", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_inqDoubleValue", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ result = (double)cdiGribIterator_inqDoubleValue(arg1,(char const *)arg2);
vresult = SWIG_From_double((double)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarTimave(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
+_wrap_cdiGribIterator_inqDoubleDefaultValue(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ double arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ double val3 ;
int ecode3 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqDoubleDefaultValue", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_inqDoubleDefaultValue", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","cdiGribIterator_inqDoubleDefaultValue", 3, argv[2] ));
}
- arg3 = (int)(val3);
- vlistDefVarTimave(arg1,arg2,arg3);
- return Qnil;
+ arg3 = (double)(val3);
+ result = (double)cdiGribIterator_inqDoubleDefaultValue(arg1,(char const *)arg2,arg3);
+ vresult = SWIG_From_double((double)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarTimave(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int result;
+_wrap_cdiGribIterator_inqStringValue(int argc, VALUE *argv, VALUE self) {
+ CdiGribIterator *arg1 = (CdiGribIterator *) 0 ;
+ char *arg2 = (char *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ char *result = 0 ;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarTimave(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_CdiGribIterator, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiGribIterator *","cdiGribIterator_inqStringValue", 1, argv[0] ));
+ }
+ arg1 = (CdiGribIterator *)(argp1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","cdiGribIterator_inqStringValue", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ result = (char *)cdiGribIterator_inqStringValue(arg1,(char const *)arg2);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefVarTimaccu(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int arg3 ;
+_wrap_vlistCreate(int argc, VALUE *argv, VALUE self) {
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ result = (int)vlistCreate();
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDestroy(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDestroy", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- vlistDefVarTimaccu(arg1,arg2,arg3);
+ vlistDestroy(arg1);
return Qnil;
fail:
return Qnil;
@@ -5322,30 +5985,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarTimaccu(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDuplicate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimaccu", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDuplicate", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimaccu", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistInqVarTimaccu(arg1,arg2);
+ result = (int)vlistDuplicate(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5354,108 +6009,78 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqVarSize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistCopy(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopy", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopy", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistInqVarSize(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ vlistCopy(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqVarID(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistCopyFlag(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarID", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarID", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)vlistInqVarID(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ vlistCopyFlag(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistClearFlag(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
- int arg4 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistClearFlag", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefIndex", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefIndex", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefIndex", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- vlistDefIndex(arg1,arg2,arg3,arg4);
+ vlistClearFlag(arg1);
return Qnil;
fail:
return Qnil;
@@ -5463,84 +6088,57 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqIndex(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistCat(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqIndex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCat", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqIndex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCat", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqIndex", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- result = (int)vlistInqIndex(arg1,arg2,arg3);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ vlistCat(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefFlag(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistMerge(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- int arg3 ;
- int arg4 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefFlag", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMerge", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefFlag", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMerge", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefFlag", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefFlag", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- vlistDefFlag(arg1,arg2,arg3,arg4);
+ vlistMerge(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -5548,70 +6146,43 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqFlag(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistPrint(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqFlag", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistPrint", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqFlag", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqFlag", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- result = (int)vlistInqFlag(arg1,arg2,arg3);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ vlistPrint(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistFindVar(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNumber(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindVar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNumber", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindVar", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistFindVar(arg1,arg2);
+ result = (int)vlistNumber(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5620,38 +6191,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistFindLevel(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNvars(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindLevel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNvars", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindLevel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistFindLevel", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- result = (int)vlistFindLevel(arg1,arg2,arg3);
+ result = (int)vlistNvars(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5660,30 +6215,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistMergedVar(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNgrids(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedVar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNgrids", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedVar", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (int)vlistMergedVar(arg1,arg2);
+ result = (int)vlistNgrids(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5692,38 +6239,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistMergedLevel(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNzaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNzaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- result = (int)vlistMergedLevel(arg1,arg2,arg3);
+ result = (int)vlistNzaxis(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5732,38 +6263,22 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqNatts(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNsubtypes(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqNatts", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNsubtypes", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqNatts", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","vlistInqNatts", 3, argv[2] ));
- }
- arg3 = (int *)(argp3);
- result = (int)vlistInqNatts(arg1,arg2,arg3);
+ result = (int)vlistNsubtypes(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -5772,525 +6287,278 @@ fail:
SWIGINTERN VALUE
-_wrap_vlistInqAtt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefNtsteps(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- int arg3 ;
- char *arg4 = (char *) 0 ;
- int *arg5 = (int *) 0 ;
- int *arg6 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
- int res4 ;
- char *buf4 = 0 ;
- int alloc4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 6) || (argc > 6)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAtt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAtt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 2, argv[1] ));
}
arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqAtt", 3, argv[2] ));
- }
- arg3 = (int)(val3);
- res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","vlistInqAtt", 4, argv[3] ));
- }
- arg4 = (char *)(buf4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqAtt", 5, argv[4] ));
- }
- arg5 = (int *)(argp5);
- res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "int *","vlistInqAtt", 6, argv[5] ));
- }
- arg6 = (int *)(argp6);
- result = (int)vlistInqAtt(arg1,arg2,arg3,arg4,arg5,arg6);
- vresult = SWIG_From_int((int)(result));
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
- return vresult;
+ vlistDefNtsteps(arg1,arg2);
+ return Qnil;
fail:
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDelAtt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNtsteps(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDelAtt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNtsteps", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDelAtt", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDelAtt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- result = (int)vlistDelAtt(arg1,arg2,(char const *)arg3);
+ result = (int)vlistNtsteps(arg1);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefAttInt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistGridsizeMax(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- int result;
+ size_t result;
VALUE vresult = Qnil;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridsizeMax", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttInt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int const *","vlistDefAttInt", 5, argv[4] ));
- }
- arg5 = (int *)(argp5);
- result = (int)vlistDefAttInt(arg1,arg2,(char const *)arg3,arg4,(int const *)arg5);
- vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ result = vlistGridsizeMax(arg1);
+ vresult = SWIG_From_size_t((size_t)(result));
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefAttFlt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistGrid(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- double *arg5 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGrid", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGrid", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttFlt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double const *","vlistDefAttFlt", 5, argv[4] ));
- }
- arg5 = (double *)(argp5);
- result = (int)vlistDefAttFlt(arg1,arg2,(char const *)arg3,arg4,(double const *)arg5);
+ result = (int)vlistGrid(arg1,arg2);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistDefAttTxt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistGridIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- char *arg5 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGridIndex", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttTxt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","vlistDefAttTxt", 5, argv[4] ));
- }
- arg5 = (char *)(buf5);
- result = (int)vlistDefAttTxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
+ result = (int)vlistGridIndex(arg1,arg2);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqAttInt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeGridIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- int *arg5 = (int *) 0 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttInt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 4, argv[3] ));
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 3, argv[2] ));
}
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqAttInt", 5, argv[4] ));
- }
- arg5 = (int *)(argp5);
- result = (int)vlistInqAttInt(arg1,arg2,(char const *)arg3,arg4,arg5);
- vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return vresult;
-fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ arg3 = (int)(val3);
+ vlistChangeGridIndex(arg1,arg2,arg3);
+ return Qnil;
+fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqAttFlt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeGrid(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- double *arg5 = (double *) 0 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttFlt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 4, argv[3] ));
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 3, argv[2] ));
}
- arg4 = (int)(val4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","vlistInqAttFlt", 5, argv[4] ));
- }
- arg5 = (double *)(argp5);
- result = (int)vlistInqAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5);
- vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return vresult;
+ arg3 = (int)(val3);
+ vlistChangeGrid(arg1,arg2,arg3);
+ return Qnil;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_vlistInqAttTxt(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistZaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
- int arg4 ;
- char *arg5 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int val4 ;
- int ecode4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxis", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttTxt", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- ecode4 = SWIG_AsVal_int(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 4, argv[3] ));
- }
- arg4 = (int)(val4);
- res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","vlistInqAttTxt", 5, argv[4] ));
- }
- arg5 = (char *)(buf5);
- result = (int)vlistInqAttTxt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ result = (int)vlistZaxis(arg1,arg2);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridName(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistZaxisIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridName", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridName", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridName(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
-fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_gridNamePtr(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- char *result = 0 ;
- VALUE vresult = Qnil;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridNamePtr", 1, argv[0] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 2, argv[1] ));
}
- arg1 = (int)(val1);
- result = (char *)gridNamePtr(arg1);
- vresult = SWIG_FromCharPtr((const char *)result);
+ arg2 = (int)(val2);
+ result = (int)vlistZaxisIndex(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -6298,20 +6566,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridCompress(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeZaxisIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCompress", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
- gridCompress(arg1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistChangeZaxisIndex(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -6319,28 +6603,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefMask(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeZaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefMask", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int const *","gridDefMask", 2, argv[1] ));
- }
- arg2 = (int *)(argp2);
- gridDefMask(arg1,(int const *)arg2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistChangeZaxis(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -6348,30 +6640,22 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqMask(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistNrecs(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqMask", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNrecs", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gridInqMask", 2, argv[1] ));
- }
- arg2 = (int *)(argp2);
- result = (int)gridInqMask(arg1,arg2);
+ result = (int)vlistNrecs(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6380,43 +6664,30 @@ fail:
SWIGINTERN VALUE
-_wrap_gridPrint(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistSubtype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridPrint", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistSubtype", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridPrint", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistSubtype", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridPrint(arg1,arg2);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_gridSize(int argc, VALUE *argv, VALUE self) {
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 0) || (argc > 0)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
- }
- result = (int)gridSize();
+ result = (int)vlistSubtype(arg1,arg2);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6425,7 +6696,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridCreate(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistSubtypeIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -6440,15 +6711,15 @@ _wrap_gridCreate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCreate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistSubtypeIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridCreate", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistSubtypeIndex", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)gridCreate(arg1,arg2);
+ result = (int)vlistSubtypeIndex(arg1,arg2);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6457,20 +6728,28 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDestroy(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefTaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDestroy", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- gridDestroy(arg1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ vlistDefTaxis(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -6478,7 +6757,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDuplicate(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqTaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -6490,10 +6769,10 @@ _wrap_gridDuplicate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDuplicate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridDuplicate(arg1);
+ result = (int)vlistInqTaxis(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6502,31 +6781,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqType(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefTable(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTable", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqType(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTable", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ vlistDefTable(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqSize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqTable(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -6538,10 +6822,10 @@ _wrap_gridInqSize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqSize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTable", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqSize(arg1);
+ result = (int)vlistInqTable(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6550,7 +6834,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefXsize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefInstitut(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -6563,15 +6847,15 @@ _wrap_gridDefXsize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXsize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefXsize", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefXsize(arg1,arg2);
+ vlistDefInstitut(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -6579,7 +6863,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqXsize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqInstitut(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -6591,10 +6875,10 @@ _wrap_gridInqXsize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXsize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqInstitut", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqXsize(arg1);
+ result = (int)vlistInqInstitut(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6603,7 +6887,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefYsize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefModel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -6616,15 +6900,15 @@ _wrap_gridDefYsize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYsize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefModel", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefYsize", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefModel", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefYsize(arg1,arg2);
+ vlistDefModel(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -6632,7 +6916,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqYsize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqModel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -6644,10 +6928,10 @@ _wrap_gridInqYsize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYsize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqModel", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqYsize(arg1);
+ result = (int)vlistInqModel(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6656,59 +6940,102 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefXvals(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVarTiles(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXvals", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTiles", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefXvals", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- gridDefXvals(arg1,(double const *)arg2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTiles", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTiles", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefVarTiles", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","vlistDefVarTiles", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ result = (int)vlistDefVarTiles(arg1,arg2,arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXvals(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXvals", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVar", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqXvals", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- result = (int)gridInqXvals(arg1,arg2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVar", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVar", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefVar", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ result = (int)vlistDefVar(arg1,arg2,arg3,arg4);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -6717,28 +7044,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefYvals(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeVarGrid(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYvals", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefYvals", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- gridDefYvals(arg1,(double const *)arg2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistChangeVarGrid(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -6746,508 +7081,6107 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqYvals(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistChangeVarZaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYvals", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqYvals", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- result = (int)gridInqYvals(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistChangeVarZaxis(arg1,arg2,arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefXname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int *arg5 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVar", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXname", 2, argv[1] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVar", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","vlistInqVar", 3, argv[2] ));
}
- arg2 = (char *)(buf2);
- gridDefXname(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","vlistInqVar", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqVar", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ vlistInqVar(arg1,arg2,arg3,arg4,arg5);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefXlongname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarGrid(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXlongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXlongname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridDefXlongname(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarGrid(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefXunits(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarZaxis(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXunits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXunits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridDefXunits(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarZaxis(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefYname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarID(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarID", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridDefYname(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarID", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarID(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefYlongname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVarTimetype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYlongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimetype", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYlongname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridDefYlongname(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimetype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimetype", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTimetype(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefYunits(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarTimetype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYunits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimetype", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYunits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridDefYunits(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimetype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTimetype(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVarTsteptype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTsteptype", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridInqXname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTsteptype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTsteptype", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTsteptype(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXlongname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarTsteptype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXlongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTsteptype", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXlongname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridInqXlongname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTsteptype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTsteptype(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXstdname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVarCompType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXstdname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarCompType", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXstdname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridInqXstdname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarCompType", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarCompType", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCompType(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXunits(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarCompType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXunits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarCompType", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXunits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridInqXunits(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
-fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
-}
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarCompType", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCompType(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
SWIGINTERN VALUE
-_wrap_gridInqYname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistDefVarCompLevel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarCompLevel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarCompLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarCompLevel", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCompLevel(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarCompLevel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarCompLevel", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYname", 2, argv[1] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarCompLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCompLevel(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarParam(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- arg2 = (char *)(buf2);
- gridInqYname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarParam", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarParam", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarParam", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarParam(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqYlongname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarParam(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYlongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarParam", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYlongname", 2, argv[1] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarParam", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarParam(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarCode(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- arg2 = (char *)(buf2);
- gridInqYlongname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarCode(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqYstdname(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarCode(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYstdname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYstdname", 2, argv[1] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarCode(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarDatatype(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- arg2 = (char *)(buf2);
- gridInqYstdname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarDatatype(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarDatatype(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarDatatype(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarChunkType(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarChunkType", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarChunkType", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarChunkType", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarChunkType(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarChunkType(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarChunkType", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarChunkType", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarChunkType(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarXYZ(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarXYZ", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarXYZ", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarXYZ", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarXYZ(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarXYZ(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarXYZ", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarXYZ", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarXYZ(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarNumber(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarNumber", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarNumber", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarNumber(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarInstitut(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarInstitut(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarInstitut(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarInstitut(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarModel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarModel(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarModel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarModel(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarTable(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTable(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarTable(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTable(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarName(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarName", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarName", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarName", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarName(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarName(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarName", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarName", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarName", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarName(arg1,arg2,arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistCopyVarName(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopyVarName", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopyVarName", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (char *)vlistCopyVarName(arg1,arg2);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarStdname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarStdname", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarStdname(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarStdname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarStdname", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarStdname(arg1,arg2,arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarLongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarLongname", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarLongname(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarLongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarLongname", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarLongname(arg1,arg2,arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarUnits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarUnits", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarUnits(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarUnits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarUnits", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarUnits(arg1,arg2,arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarMissval(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarMissval", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ vlistDefVarMissval(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarMissval(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarMissval(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarExtra(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarExtra", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarExtra", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarExtra", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistDefVarExtra(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarExtra(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarExtra", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarExtra", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarExtra", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ vlistInqVarExtra(arg1,arg2,arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarScalefactor(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarScalefactor", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ vlistDefVarScalefactor(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarScalefactor(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarScalefactor(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarAddoffset(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarAddoffset", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ vlistDefVarAddoffset(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarAddoffset(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (double)vlistInqVarAddoffset(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarTimave(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ vlistDefVarTimave(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarTimave(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarTimave(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarSize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = vlistInqVarSize(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefIndex(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefIndex", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefIndex", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefIndex", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefIndex", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ vlistDefIndex(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqIndex(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqIndex", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqIndex", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqIndex", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistInqIndex(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefFlag(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefFlag", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefFlag", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefFlag", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefFlag", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ vlistDefFlag(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqFlag(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqFlag", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqFlag", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqFlag", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistInqFlag(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistFindVar(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindVar", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindVar", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistFindVar(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistFindLevel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindLevel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistFindLevel", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistFindLevel(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistMergedVar(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedVar", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedVar", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistMergedVar(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistMergedLevel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)vlistMergedLevel(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiClearAdditionalKeys(int argc, VALUE *argv, VALUE self) {
+ if ((argc < 0) || (argc > 0)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+ }
+ cdiClearAdditionalKeys();
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefAdditionalKey(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiDefAdditionalKey", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
+ cdiDefAdditionalKey((char const *)arg1);
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarIntKey(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarIntKey", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarIntKey", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarIntKey", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefVarIntKey", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ vlistDefVarIntKey(arg1,arg2,(char const *)arg3,arg4);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistDefVarDblKey(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ double arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarDblKey", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarDblKey", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarDblKey", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_double(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","vlistDefVarDblKey", 4, argv[3] ));
+ }
+ arg4 = (double)(val4);
+ vlistDefVarDblKey(arg1,arg2,(char const *)arg3,arg4);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistHasVarKey(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistHasVarKey", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistHasVarKey", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistHasVarKey", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ result = (int)vlistHasVarKey(arg1,arg2,(char const *)arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarDblKey(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarDblKey", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarDblKey", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqVarDblKey", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ result = (double)vlistInqVarDblKey(arg1,arg2,(char const *)arg3);
+ vresult = SWIG_From_double((double)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_vlistInqVarIntKey(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarIntKey", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarIntKey", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqVarIntKey", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ result = (int)vlistInqVarIntKey(arg1,arg2,(char const *)arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqNatts(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int *arg3 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqNatts", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqNatts", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","cdiInqNatts", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ result = (int)cdiInqNatts(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqAtt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int *arg5 = (int *) 0 ;
+ int *arg6 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 6) || (argc > 6)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqAtt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqAtt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiInqAtt", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","cdiInqAtt", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","cdiInqAtt", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "int *","cdiInqAtt", 6, argv[5] ));
+ }
+ arg6 = (int *)(argp6);
+ result = (int)cdiInqAtt(arg1,arg2,arg3,arg4,arg5,arg6);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDelAtt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDelAtt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDelAtt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiDelAtt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ result = (int)cdiDelAtt(arg1,arg2,(char const *)arg3);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiCopyAtts(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiCopyAtts", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiCopyAtts", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiCopyAtts", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiCopyAtts", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiCopyAtts(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefAttInt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ int *arg6 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 6) || (argc > 6)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefAttInt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefAttInt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiDefAttInt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiDefAttInt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","cdiDefAttInt", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "int const []","cdiDefAttInt", 6, argv[5] ));
+ }
+ arg6 = (int *)(argp6);
+ result = (int)cdiDefAttInt(arg1,arg2,(char const *)arg3,arg4,arg5,(int const (*))arg6);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefAttFlt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int arg5 ;
+ double *arg6 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 6) || (argc > 6)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefAttFlt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefAttFlt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiDefAttFlt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiDefAttFlt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","cdiDefAttFlt", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double const []","cdiDefAttFlt", 6, argv[5] ));
+ }
+ arg6 = (double *)(argp6);
+ result = (int)cdiDefAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5,(double const (*))arg6);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefAttTxt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefAttTxt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefAttTxt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiDefAttTxt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiDefAttTxt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","cdiDefAttTxt", 5, argv[4] ));
+ }
+ arg5 = (char *)(buf5);
+ result = (int)cdiDefAttTxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqAttInt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ int *arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqAttInt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqAttInt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiInqAttInt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiInqAttInt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int []","cdiInqAttInt", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqAttInt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqAttFlt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ double *arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqAttFlt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqAttFlt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiInqAttFlt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiInqAttFlt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double []","cdiInqAttFlt", 5, argv[4] ));
+ }
+ arg5 = (double *)(argp5);
+ result = (int)cdiInqAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqAttTxt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int arg4 ;
+ char *arg5 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int res5 ;
+ char *buf5 = 0 ;
+ int alloc5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqAttTxt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqAttTxt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","cdiInqAttTxt", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiInqAttTxt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","cdiInqAttTxt", 5, argv[4] ));
+ }
+ arg5 = (char *)(buf5);
+ result = (int)cdiInqAttTxt(arg1,arg2,(char const *)arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return vresult;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridName(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridName", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridName", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridName(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridNamePtr(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ char *result = 0 ;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridNamePtr", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (char *)gridNamePtr(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridCompress(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCompress", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ gridCompress(arg1);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefMaskGME(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefMaskGME", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int const []","gridDefMaskGME", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ gridDefMaskGME(arg1,(int const (*))arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqMaskGME(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqMaskGME", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int []","gridInqMaskGME", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ result = (int)gridInqMaskGME(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefMask(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefMask", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int const []","gridDefMask", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ gridDefMask(arg1,(int const (*))arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqMask(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqMask", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int []","gridInqMask", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ result = (int)gridInqMask(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridCreate(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCreate", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","gridCreate", 2, argv[1] ));
+ }
+ arg2 = (size_t)(val2);
+ result = (int)gridCreate(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDestroy(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDestroy", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ gridDestroy(arg1);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDuplicate(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDuplicate", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridDuplicate(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefProj(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefProj", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefProj", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefProj(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqProj(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqProj", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqProj(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqProjType(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqProjType", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqProjType(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqType(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqType", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqType(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqSize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqSize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = gridInqSize(arg1);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefXsize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXsize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","gridDefXsize", 2, argv[1] ));
+ }
+ arg2 = (size_t)(val2);
+ gridDefXsize(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXsize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXsize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = gridInqXsize(arg1);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefYsize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYsize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","gridDefYsize", 2, argv[1] ));
+ }
+ arg2 = (size_t)(val2);
+ gridDefYsize(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYsize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYsize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = gridInqYsize(arg1);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefNP(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefNP", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefNP", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefNP(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqNP(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqNP", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqNP(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefXvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","gridDefXvals", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ gridDefXvals(arg1,(double const (*))arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","gridInqXvals", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqXvals(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXvalsPart(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXvalsPart", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqXvalsPart", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","gridInqXvalsPart", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double []","gridInqXvalsPart", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqXvalsPart(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXIsc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXIsc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqXIsc(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXCvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char **arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXCvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *[]","gridInqXCvals", 2, argv[1] ));
+ }
+ arg2 = (char **)(argp2);
+ result = gridInqXCvals(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefYvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","gridDefYvals", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ gridDefYvals(arg1,(double const (*))arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","gridInqYvals", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqYvals(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYvalsPart(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYvalsPart", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqYvalsPart", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","gridInqYvalsPart", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double []","gridInqYvalsPart", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqYvalsPart(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYIsc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYIsc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqYIsc(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYCvals(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char **arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYCvals", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *[]","gridInqYCvals", 2, argv[1] ));
+ }
+ arg2 = (char **)(argp2);
+ result = gridInqYCvals(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefKeyInt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefKeyInt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefKeyInt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiDefKeyInt", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiDefKeyInt", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiDefKeyInt(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqKeyInt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqKeyInt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqKeyInt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiInqKeyInt", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiInqKeyInt", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ result = (int)cdiInqKeyInt(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefKeyBytes(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ unsigned char *arg4 ;
+ int arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefKeyBytes", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefKeyBytes", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiDefKeyBytes", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned char const []","cdiDefKeyBytes", 4, argv[3] ));
+ }
+ arg4 = (unsigned char *)(argp4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","cdiDefKeyBytes", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ result = (int)cdiDefKeyBytes(arg1,arg2,arg3,(unsigned char const (*))arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqKeyBytes(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ unsigned char *arg4 ;
+ int *arg5 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqKeyBytes", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqKeyBytes", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiInqKeyBytes", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned char []","cdiInqKeyBytes", 4, argv[3] ));
+ }
+ arg4 = (unsigned char *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","cdiInqKeyBytes", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqKeyBytes(arg1,arg2,arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiDefKeyString(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDefKeyString", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefKeyString", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiDefKeyString", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","cdiDefKeyString", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiDefKeyString(arg1,arg2,arg3,(char const *)arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqKeyString(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int *arg5 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqKeyString", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqKeyString", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiInqKeyString", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","cdiInqKeyString", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","cdiInqKeyString", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ result = (int)cdiInqKeyString(arg1,arg2,arg3,arg4,arg5);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiInqKeyLen(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int *arg4 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiInqKeyLen", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiInqKeyLen", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiInqKeyLen", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","cdiInqKeyLen", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ result = (int)cdiInqKeyLen(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiCopyKeys(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiCopyKeys", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiCopyKeys", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiCopyKeys", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","cdiCopyKeys", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ result = (int)cdiCopyKeys(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiGridDefKeyStr(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiGridDefKeyStr", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiGridDefKeyStr", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiGridDefKeyStr", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","cdiGridDefKeyStr", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiGridDefKeyStr(arg1,arg2,arg3,(char const *)arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiGridInqKeyStr(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiGridInqKeyStr", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiGridInqKeyStr", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiGridInqKeyStr", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","cdiGridInqKeyStr", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiGridInqKeyStr(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiZaxisDefKeyStr(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiZaxisDefKeyStr", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiZaxisDefKeyStr", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiZaxisDefKeyStr", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","cdiZaxisDefKeyStr", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiZaxisDefKeyStr(arg1,arg2,arg3,(char const *)arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiZaxisInqKeyStr(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ char *arg4 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int res4 ;
+ char *buf4 = 0 ;
+ int alloc4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiZaxisInqKeyStr", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiZaxisInqKeyStr", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","cdiZaxisInqKeyStr", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","cdiZaxisInqKeyStr", 4, argv[3] ));
+ }
+ arg4 = (char *)(buf4);
+ result = (int)cdiZaxisInqKeyStr(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return vresult;
+fail:
+ if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiZaxisDefKeyFlt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiZaxisDefKeyFlt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiZaxisDefKeyFlt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","cdiZaxisDefKeyFlt", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ result = (int)cdiZaxisDefKeyFlt(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_cdiZaxisInqKeyFlt(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double *arg3 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiZaxisInqKeyFlt", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiZaxisInqKeyFlt", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","cdiZaxisInqKeyFlt", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ result = (int)cdiZaxisInqKeyFlt(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefXname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefXname(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqXname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefXlongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXlongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXlongname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefXlongname(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXlongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXlongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXlongname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqXlongname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefXunits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXunits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXunits", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefXunits(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXunits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXunits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXunits", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqXunits(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefYname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefYname(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqYname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefYlongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYlongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYlongname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefYlongname(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYlongname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYlongname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYlongname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqYlongname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefYunits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYunits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYunits", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefYunits(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYunits(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYunits", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYunits", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqYunits(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXstdname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXstdname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXstdname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqXstdname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYstdname(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYstdname", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYstdname", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridInqYstdname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefDatatype(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefDatatype", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefDatatype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefDatatype(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqDatatype(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqDatatype", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqDatatype(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXval(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXval", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","gridInqXval", 2, argv[1] ));
+ }
+ arg2 = (size_t)(val2);
+ result = (double)gridInqXval(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYval(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ size_t arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ size_t val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYval", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","gridInqYval", 2, argv[1] ));
+ }
+ arg2 = (size_t)(val2);
+ result = (double)gridInqYval(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqXinc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXinc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (double)gridInqXinc(arg1);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqYinc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYinc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (double)gridInqYinc(arg1);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridIsCircular(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridIsCircular", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridIsCircular(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqTrunc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqTrunc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqTrunc(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefTrunc(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefTrunc", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefTrunc", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefTrunc(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefNumber(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefNumber", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefNumber", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefNumber(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqNumber(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqNumber", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqNumber(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefPosition(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefPosition", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefPosition", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefPosition(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqPosition(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqPosition", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)gridInqPosition(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefReference(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefReference", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefReference", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ gridDefReference(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqReference(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqReference", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqReference", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ result = (int)gridInqReference(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return vresult;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefUUID(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ unsigned char *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefUUID", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char const [16]","gridDefUUID", 2, argv[1] ));
+ }
+ arg2 = (unsigned char *)(argp2);
+ gridDefUUID(arg1,(unsigned char const (*))arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqUUID(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ unsigned char *arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqUUID", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [16]","gridInqUUID", 2, argv[1] ));
+ }
+ arg2 = (unsigned char *)(argp2);
+ gridInqUUID(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefParamRLL(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefParamRLL", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefParamRLL", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefParamRLL", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefParamRLL", 4, argv[3] ));
+ }
+ arg4 = (double)(val4);
+ gridDefParamRLL(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqParamRLL(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double *arg2 = (double *) 0 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqParamRLL", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqParamRLL", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqParamRLL", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqParamRLL", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ gridInqParamRLL(arg1,arg2,arg3,arg4);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefParamGME(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int arg3 ;
+ int arg4 ;
+ int arg5 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int val4 ;
+ int ecode4 = 0 ;
+ int val5 ;
+ int ecode5 = 0 ;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefParamGME", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefParamGME", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","gridDefParamGME", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","gridDefParamGME", 4, argv[3] ));
+ }
+ arg4 = (int)(val4);
+ ecode5 = SWIG_AsVal_int(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","gridDefParamGME", 5, argv[4] ));
+ }
+ arg5 = (int)(val5);
+ gridDefParamGME(arg1,arg2,arg3,arg4,arg5);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqParamGME(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ int *arg4 = (int *) 0 ;
+ int *arg5 = (int *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+
+ if ((argc < 5) || (argc > 5)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqParamGME", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gridInqParamGME", 2, argv[1] ));
+ }
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","gridInqParamGME", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","gridInqParamGME", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","gridInqParamGME", 5, argv[4] ));
+ }
+ arg5 = (int *)(argp5);
+ gridInqParamGME(arg1,arg2,arg3,arg4,arg5);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefParamLCC(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double arg8 ;
+ double arg9 ;
+ double arg10 ;
+ double arg11 ;
+ double arg12 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ double val9 ;
+ int ecode9 = 0 ;
+ double val10 ;
+ int ecode10 = 0 ;
+ double val11 ;
+ int ecode11 = 0 ;
+ double val12 ;
+ int ecode12 = 0 ;
+
+ if ((argc < 12) || (argc > 12)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefParamLCC", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 4, argv[3] ));
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 5, argv[4] ));
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double(argv[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 6, argv[5] ));
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(argv[6], &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 7, argv[6] ));
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(argv[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 8, argv[7] ));
+ }
+ arg8 = (double)(val8);
+ ecode9 = SWIG_AsVal_double(argv[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 9, argv[8] ));
+ }
+ arg9 = (double)(val9);
+ ecode10 = SWIG_AsVal_double(argv[9], &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 10, argv[9] ));
+ }
+ arg10 = (double)(val10);
+ ecode11 = SWIG_AsVal_double(argv[10], &val11);
+ if (!SWIG_IsOK(ecode11)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 11, argv[10] ));
+ }
+ arg11 = (double)(val11);
+ ecode12 = SWIG_AsVal_double(argv[11], &val12);
+ if (!SWIG_IsOK(ecode12)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","gridDefParamLCC", 12, argv[11] ));
+ }
+ arg12 = (double)(val12);
+ gridDefParamLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqParamLCC(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double arg2 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ double *arg5 = (double *) 0 ;
+ double *arg6 = (double *) 0 ;
+ double *arg7 = (double *) 0 ;
+ double *arg8 = (double *) 0 ;
+ double *arg9 = (double *) 0 ;
+ double *arg10 = (double *) 0 ;
+ double *arg11 = (double *) 0 ;
+ double *arg12 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ void *argp11 = 0 ;
+ int res11 = 0 ;
+ void *argp12 = 0 ;
+ int res12 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 12) || (argc > 12)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqParamLCC", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridInqParamLCC", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 5, argv[4] ));
+ }
+ arg5 = (double *)(argp5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 6, argv[5] ));
+ }
+ arg6 = (double *)(argp6);
+ res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 7, argv[6] ));
+ }
+ arg7 = (double *)(argp7);
+ res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 8, argv[7] ));
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(argv[8], &argp9,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 9, argv[8] ));
+ }
+ arg9 = (double *)(argp9);
+ res10 = SWIG_ConvertPtr(argv[9], &argp10,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 10, argv[9] ));
+ }
+ arg10 = (double *)(argp10);
+ res11 = SWIG_ConvertPtr(argv[10], &argp11,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res11)) {
+ SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 11, argv[10] ));
+ }
+ arg11 = (double *)(argp11);
+ res12 = SWIG_ConvertPtr(argv[11], &argp12,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res12)) {
+ SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "double *","gridInqParamLCC", 12, argv[11] ));
+ }
+ arg12 = (double *)(argp12);
+ result = (int)gridInqParamLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridDefParamSTERE(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double arg2 ;
+ double arg3 ;
+ double arg4 ;
+ double arg5 ;
+ double arg6 ;
+ double arg7 ;
+ double arg8 ;
+ double arg9 ;
+ double arg10 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+ double val4 ;
+ int ecode4 = 0 ;
+ double val5 ;
+ int ecode5 = 0 ;
+ double val6 ;
+ int ecode6 = 0 ;
+ double val7 ;
+ int ecode7 = 0 ;
+ double val8 ;
+ int ecode8 = 0 ;
+ double val9 ;
+ int ecode9 = 0 ;
+ double val10 ;
+ int ecode10 = 0 ;
+
+ if ((argc < 10) || (argc > 10)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefParamSTERE", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ ecode4 = SWIG_AsVal_double(argv[3], &val4);
+ if (!SWIG_IsOK(ecode4)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 4, argv[3] ));
+ }
+ arg4 = (double)(val4);
+ ecode5 = SWIG_AsVal_double(argv[4], &val5);
+ if (!SWIG_IsOK(ecode5)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 5, argv[4] ));
+ }
+ arg5 = (double)(val5);
+ ecode6 = SWIG_AsVal_double(argv[5], &val6);
+ if (!SWIG_IsOK(ecode6)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 6, argv[5] ));
+ }
+ arg6 = (double)(val6);
+ ecode7 = SWIG_AsVal_double(argv[6], &val7);
+ if (!SWIG_IsOK(ecode7)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 7, argv[6] ));
+ }
+ arg7 = (double)(val7);
+ ecode8 = SWIG_AsVal_double(argv[7], &val8);
+ if (!SWIG_IsOK(ecode8)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 8, argv[7] ));
+ }
+ arg8 = (double)(val8);
+ ecode9 = SWIG_AsVal_double(argv[8], &val9);
+ if (!SWIG_IsOK(ecode9)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 9, argv[8] ));
+ }
+ arg9 = (double)(val9);
+ ecode10 = SWIG_AsVal_double(argv[9], &val10);
+ if (!SWIG_IsOK(ecode10)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "double","gridDefParamSTERE", 10, argv[9] ));
+ }
+ arg10 = (double)(val10);
+ gridDefParamSTERE(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gridInqParamSTERE(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ double arg2 ;
+ double *arg3 = (double *) 0 ;
+ double *arg4 = (double *) 0 ;
+ double *arg5 = (double *) 0 ;
+ double *arg6 = (double *) 0 ;
+ double *arg7 = (double *) 0 ;
+ double *arg8 = (double *) 0 ;
+ double *arg9 = (double *) 0 ;
+ double *arg10 = (double *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ double val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ void *argp5 = 0 ;
+ int res5 = 0 ;
+ void *argp6 = 0 ;
+ int res6 = 0 ;
+ void *argp7 = 0 ;
+ int res7 = 0 ;
+ void *argp8 = 0 ;
+ int res8 = 0 ;
+ void *argp9 = 0 ;
+ int res9 = 0 ;
+ void *argp10 = 0 ;
+ int res10 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 10) || (argc > 10)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqParamSTERE", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridInqParamSTERE", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res5)) {
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 5, argv[4] ));
+ }
+ arg5 = (double *)(argp5);
+ res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 6, argv[5] ));
+ }
+ arg6 = (double *)(argp6);
+ res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res7)) {
+ SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 7, argv[6] ));
+ }
+ arg7 = (double *)(argp7);
+ res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res8)) {
+ SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 8, argv[7] ));
+ }
+ arg8 = (double *)(argp8);
+ res9 = SWIG_ConvertPtr(argv[8], &argp9,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res9)) {
+ SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 9, argv[8] ));
+ }
+ arg9 = (double *)(argp9);
+ res10 = SWIG_ConvertPtr(argv[9], &argp10,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res10)) {
+ SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "double *","gridInqParamSTERE", 10, argv[9] ));
+ }
+ arg10 = (double *)(argp10);
+ result = (int)gridInqParamSTERE(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqYunits(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefArea(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYunits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefArea", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYunits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- gridInqYunits(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","gridDefArea", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ gridDefArea(arg1,(double const (*))arg2);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefDatatype(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqArea(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefDatatype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqArea", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefDatatype", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","gridInqArea", 2, argv[1] ));
}
- arg2 = (int)(val2);
- gridDefDatatype(arg1,arg2);
+ arg2 = (double *)(argp2);
+ gridInqArea(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -7255,7 +13189,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqDatatype(int argc, VALUE *argv, VALUE self) {
+_wrap_gridHasArea(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -7267,10 +13201,10 @@ _wrap_gridInqDatatype(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqDatatype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridHasArea", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqDatatype(arg1);
+ result = (int)gridHasArea(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -7279,75 +13213,40 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqXval(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefNvertex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXval", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefNvertex", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqXval", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefNvertex", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (double)gridInqXval(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
- return vresult;
-fail:
+ gridDefNvertex(arg1,arg2);
return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_gridInqYval(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYval", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqYval", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (double)gridInqYval(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
- return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqXinc(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqNvertex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- double result;
+ int result;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -7355,11 +13254,11 @@ _wrap_gridInqXinc(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXinc", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqNvertex", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double)gridInqXinc(arg1);
- vresult = SWIG_From_double((double)(result));
+ result = (int)gridInqNvertex(arg1);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -7367,71 +13266,60 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqYinc(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefXbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYinc", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double)gridInqYinc(arg1);
- vresult = SWIG_From_double((double)(result));
- return vresult;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_gridIsCircular(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridIsCircular", 1, argv[0] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","gridDefXbounds", 2, argv[1] ));
}
- arg1 = (int)(val1);
- result = (int)gridIsCircular(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (double *)(argp2);
+ gridDefXbounds(arg1,(double const (*))arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridIsRotated(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqXbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridIsRotated", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridIsRotated(arg1);
- vresult = SWIG_From_int((int)(result));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","gridInqXbounds", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqXbounds(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
return vresult;
fail:
return Qnil;
@@ -7439,23 +13327,47 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqXpole(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqXboundsPart(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
- double result;
+ int val2 ;
+ int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXpole", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXboundsPart", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double)gridInqXpole(arg1);
- vresult = SWIG_From_double((double)(result));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqXboundsPart", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","gridInqXboundsPart", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double []","gridInqXboundsPart", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqXboundsPart(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_size_t((size_t)(result));
return vresult;
fail:
return Qnil;
@@ -7463,28 +13375,28 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefXpole(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefYbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXpole", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefXpole", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","gridDefYbounds", 2, argv[1] ));
}
- arg2 = (double)(val2);
- gridDefXpole(arg1,arg2);
+ arg2 = (double *)(argp2);
+ gridDefYbounds(arg1,(double const (*))arg2);
return Qnil;
fail:
return Qnil;
@@ -7492,23 +13404,31 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqYpole(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqYbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double result;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYpole", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double)gridInqYpole(arg1);
- vresult = SWIG_From_double((double)(result));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","gridInqYbounds", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = gridInqYbounds(arg1,arg2);
+ vresult = SWIG_From_size_t((size_t)(result));
return vresult;
fail:
return Qnil;
@@ -7516,81 +13436,113 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefYpole(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqYboundsPart(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
+ int arg2 ;
+ size_t arg3 ;
+ double *arg4 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
+ int val2 ;
int ecode2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ size_t result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYpole", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYboundsPart", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefYpole", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqYboundsPart", 2, argv[1] ));
}
- arg2 = (double)(val2);
- gridDefYpole(arg1,arg2);
- return Qnil;
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","gridInqYboundsPart", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double []","gridInqYboundsPart", 4, argv[3] ));
+ }
+ arg4 = (double *)(argp4);
+ result = gridInqYboundsPart(arg1,arg2,arg3,arg4);
+ vresult = SWIG_From_size_t((size_t)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqAngle(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefReducedPoints(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
+ int *arg3 ;
int val1 ;
int ecode1 = 0 ;
- double result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqAngle", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefReducedPoints", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double)gridInqAngle(arg1);
- vresult = SWIG_From_double((double)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefReducedPoints", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const []","gridDefReducedPoints", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ gridDefReducedPoints(arg1,arg2,(int const (*))arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefAngle(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqReducedPoints(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
+ int *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefAngle", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqReducedPoints", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefAngle", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int []","gridInqReducedPoints", 2, argv[1] ));
}
- arg2 = (double)(val2);
- gridDefAngle(arg1,arg2);
+ arg2 = (int *)(argp2);
+ gridInqReducedPoints(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -7598,7 +13550,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefTrunc(int argc, VALUE *argv, VALUE self) {
+_wrap_gridChangeType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -7611,15 +13563,15 @@ _wrap_gridDefTrunc(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefTrunc", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridChangeType", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefTrunc", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridChangeType", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefTrunc(arg1,arg2);
+ gridChangeType(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -7627,31 +13579,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqTrunc(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefComplexPacking(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqTrunc", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefComplexPacking", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqTrunc(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefComplexPacking", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ gridDefComplexPacking(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqGMEnd(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqComplexPacking(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -7663,10 +13620,10 @@ _wrap_gridInqGMEnd(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEnd", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqComplexPacking", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqGMEnd(arg1);
+ result = (int)gridInqComplexPacking(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -7675,7 +13632,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefGMEnd(int argc, VALUE *argv, VALUE self) {
+_wrap_gridDefScanningMode(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -7688,15 +13645,15 @@ _wrap_gridDefGMEnd(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEnd", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefScanningMode", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEnd", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefScanningMode", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefGMEnd(arg1,arg2);
+ gridDefScanningMode(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -7704,7 +13661,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqGMEni(int argc, VALUE *argv, VALUE self) {
+_wrap_gridInqScanningMode(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -7716,10 +13673,10 @@ _wrap_gridInqGMEni(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqScanningMode", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni(arg1);
+ result = (int)gridInqScanningMode(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -7728,40 +13685,43 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefGMEni(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisName(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisName", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- gridDefGMEni(arg1,arg2);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisName", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ zaxisName(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqGMEni2(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisNamePtr(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ char *result = 0 ;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -7769,11 +13729,11 @@ _wrap_gridInqGMEni2(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni2", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisNamePtr", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni2(arg1);
- vresult = SWIG_From_int((int)(result));
+ result = (char *)zaxisNamePtr(arg1);
+ vresult = SWIG_FromCharPtr((const char *)result);
return vresult;
fail:
return Qnil;
@@ -7781,28 +13741,52 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefGMEni2(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisCreate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni2", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisCreate", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni2", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisCreate", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefGMEni2(arg1,arg2);
+ result = (int)zaxisCreate(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_zaxisDestroy(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDestroy", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ zaxisDestroy(arg1);
return Qnil;
fail:
return Qnil;
@@ -7810,7 +13794,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqGMEni3(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -7822,10 +13806,10 @@ _wrap_gridInqGMEni3(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni3", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqType", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqGMEni3(arg1);
+ result = (int)zaxisInqType(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -7834,214 +13818,76 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefGMEni3(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqSize(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni3", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqSize", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni3", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- gridDefGMEni3(arg1,arg2);
- return Qnil;
+ result = (int)zaxisInqSize(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefLCC(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDuplicate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
- double arg5 ;
- double arg6 ;
- double arg7 ;
- double arg8 ;
- int arg9 ;
- int arg10 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
- double val5 ;
- int ecode5 = 0 ;
- double val6 ;
- int ecode6 = 0 ;
- double val7 ;
- int ecode7 = 0 ;
- double val8 ;
- int ecode8 = 0 ;
- int val9 ;
- int ecode9 = 0 ;
- int val10 ;
- int ecode10 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 10) || (argc > 10)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLCC", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDuplicate", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLCC", 2, argv[1] ));
- }
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLCC", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLCC", 4, argv[3] ));
- }
- arg4 = (double)(val4);
- ecode5 = SWIG_AsVal_double(argv[4], &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefLCC", 5, argv[4] ));
- }
- arg5 = (double)(val5);
- ecode6 = SWIG_AsVal_double(argv[5], &val6);
- if (!SWIG_IsOK(ecode6)) {
- SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefLCC", 6, argv[5] ));
- }
- arg6 = (double)(val6);
- ecode7 = SWIG_AsVal_double(argv[6], &val7);
- if (!SWIG_IsOK(ecode7)) {
- SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","gridDefLCC", 7, argv[6] ));
- }
- arg7 = (double)(val7);
- ecode8 = SWIG_AsVal_double(argv[7], &val8);
- if (!SWIG_IsOK(ecode8)) {
- SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","gridDefLCC", 8, argv[7] ));
- }
- arg8 = (double)(val8);
- ecode9 = SWIG_AsVal_int(argv[8], &val9);
- if (!SWIG_IsOK(ecode9)) {
- SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","gridDefLCC", 9, argv[8] ));
- }
- arg9 = (int)(val9);
- ecode10 = SWIG_AsVal_int(argv[9], &val10);
- if (!SWIG_IsOK(ecode10)) {
- SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","gridDefLCC", 10, argv[9] ));
- }
- arg10 = (int)(val10);
- gridDefLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
- return Qnil;
+ result = (int)zaxisDuplicate(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqLCC(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefLevels(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
- double *arg5 = (double *) 0 ;
- double *arg6 = (double *) 0 ;
- double *arg7 = (double *) 0 ;
- double *arg8 = (double *) 0 ;
- int *arg9 = (int *) 0 ;
- int *arg10 = (int *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
- void *argp7 = 0 ;
- int res7 = 0 ;
- void *argp8 = 0 ;
- int res8 = 0 ;
- void *argp9 = 0 ;
- int res9 = 0 ;
- void *argp10 = 0 ;
- int res10 = 0 ;
- if ((argc < 10) || (argc > 10)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLCC", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevels", 1, argv[0] ));
}
arg1 = (int)(val1);
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLCC", 2, argv[1] ));
- }
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","zaxisDefLevels", 2, argv[1] ));
+ }
arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLCC", 3, argv[2] ));
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLCC", 4, argv[3] ));
- }
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqLCC", 5, argv[4] ));
- }
- arg5 = (double *)(argp5);
- res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqLCC", 6, argv[5] ));
- }
- arg6 = (double *)(argp6);
- res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res7)) {
- SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "double *","gridInqLCC", 7, argv[6] ));
- }
- arg7 = (double *)(argp7);
- res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res8)) {
- SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "double *","gridInqLCC", 8, argv[7] ));
- }
- arg8 = (double *)(argp8);
- res9 = SWIG_ConvertPtr(argv[8], &argp9,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res9)) {
- SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "int *","gridInqLCC", 9, argv[8] ));
- }
- arg9 = (int *)(argp9);
- res10 = SWIG_ConvertPtr(argv[9], &argp10,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res10)) {
- SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "int *","gridInqLCC", 10, argv[9] ));
- }
- arg10 = (int *)(argp10);
- gridInqLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+ zaxisDefLevels(arg1,(double const (*))arg2);
return Qnil;
fail:
return Qnil;
@@ -8049,60 +13895,36 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefLcc2(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefCvals(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
- double arg5 ;
- double arg6 ;
+ char **arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int val3 ;
int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
- double val5 ;
- int ecode5 = 0 ;
- double val6 ;
- int ecode6 = 0 ;
- if ((argc < 6) || (argc > 6)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLcc2", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefCvals", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLcc2", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *[]","zaxisDefCvals", 2, argv[1] ));
}
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ arg2 = (char **)(argp2);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLcc2", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLcc2", 4, argv[3] ));
- }
- arg4 = (double)(val4);
- ecode5 = SWIG_AsVal_double(argv[4], &val5);
- if (!SWIG_IsOK(ecode5)) {
- SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefLcc2", 5, argv[4] ));
- }
- arg5 = (double)(val5);
- ecode6 = SWIG_AsVal_double(argv[5], &val6);
- if (!SWIG_IsOK(ecode6)) {
- SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefLcc2", 6, argv[5] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","zaxisDefCvals", 3, argv[2] ));
}
- arg6 = (double)(val6);
- gridDefLcc2(arg1,arg2,arg3,arg4,arg5,arg6);
+ arg3 = (int)(val3);
+ zaxisDefCvals(arg1,(char const *(*))arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -8110,150 +13932,124 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqLcc2(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLevels(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
- double *arg5 = (double *) 0 ;
- double *arg6 = (double *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
- void *argp5 = 0 ;
- int res5 = 0 ;
- void *argp6 = 0 ;
- int res6 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 6) || (argc > 6)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLcc2", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevels", 1, argv[0] ));
}
arg1 = (int)(val1);
res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 2, argv[1] ));
- }
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","zaxisInqLevels", 2, argv[1] ));
+ }
arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 3, argv[2] ));
- }
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 4, argv[3] ));
- }
- arg4 = (double *)(argp4);
- res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 5, argv[4] ));
- }
- arg5 = (double *)(argp5);
- res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res6)) {
- SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 6, argv[5] ));
- }
- arg6 = (double *)(argp6);
- gridInqLcc2(arg1,arg2,arg3,arg4,arg5,arg6);
- return Qnil;
+ result = (int)zaxisInqLevels(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefLaea(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqCLen(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double arg2 ;
- double arg3 ;
- double arg4 ;
int val1 ;
int ecode1 = 0 ;
- double val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
- double val4 ;
- int ecode4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLaea", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqCLen", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_double(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLaea", 2, argv[1] ));
- }
- arg2 = (double)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLaea", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- ecode4 = SWIG_AsVal_double(argv[3], &val4);
- if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLaea", 4, argv[3] ));
- }
- arg4 = (double)(val4);
- gridDefLaea(arg1,arg2,arg3,arg4);
- return Qnil;
+ result = (int)zaxisInqCLen(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqLaea(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqCVals(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
- double *arg3 = (double *) 0 ;
- double *arg4 = (double *) 0 ;
+ char ***arg2 = (char ***) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- void *argp4 = 0 ;
- int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 4) || (argc > 4)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLaea", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqCVals", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_p_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLaea", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLaea", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char ***","zaxisInqCVals", 2, argv[1] ));
}
- arg3 = (double *)(argp3);
- res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLaea", 4, argv[3] ));
+ arg2 = (char ***)(argp2);
+ result = (int)zaxisInqCVals(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_zaxisDefLevel(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ double arg3 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- arg4 = (double *)(argp4);
- gridInqLaea(arg1,arg2,arg3,arg4);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ ecode3 = SWIG_AsVal_double(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","zaxisDefLevel", 3, argv[2] ));
+ }
+ arg3 = (double)(val3);
+ zaxisDefLevel(arg1,arg2,arg3);
return Qnil;
fail:
return Qnil;
@@ -8261,57 +14057,60 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefArea(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLevel(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefArea", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefArea", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- gridDefArea(arg1,(double const *)arg2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (double)zaxisInqLevel(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqArea(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefNlevRef(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqArea", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefNlevRef", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqArea", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- gridInqArea(arg1,arg2);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefNlevRef", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ zaxisDefNlevRef(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -8319,7 +14118,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridHasArea(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqNlevRef(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -8331,10 +14130,10 @@ _wrap_gridHasArea(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridHasArea", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqNlevRef", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridHasArea(arg1);
+ result = (int)zaxisInqNlevRef(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -8343,7 +14142,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefNvertex(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefNumber(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -8356,15 +14155,15 @@ _wrap_gridDefNvertex(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefNvertex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefNumber", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefNvertex", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefNumber", 2, argv[1] ));
}
arg2 = (int)(val2);
- gridDefNvertex(arg1,arg2);
+ zaxisDefNumber(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -8372,7 +14171,7 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqNvertex(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqNumber(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -8384,10 +14183,10 @@ _wrap_gridInqNvertex(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqNvertex", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqNumber", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)gridInqNvertex(arg1);
+ result = (int)zaxisInqNumber(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -8396,9 +14195,9 @@ fail:
SWIGINTERN VALUE
-_wrap_gridDefXbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefUUID(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
@@ -8409,15 +14208,15 @@ _wrap_gridDefXbounds(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUUID", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefXbounds", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- gridDefXbounds(arg1,(double const *)arg2);
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char const [16]","zaxisDefUUID", 2, argv[1] ));
+ }
+ arg2 = (unsigned char *)(argp2);
+ zaxisDefUUID(arg1,(unsigned char const (*))arg2);
return Qnil;
fail:
return Qnil;
@@ -8425,195 +14224,228 @@ fail:
SWIGINTERN VALUE
-_wrap_gridInqXbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqUUID(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ unsigned char *arg2 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUUID", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [16]","zaxisInqUUID", 2, argv[1] ));
+ }
+ arg2 = (unsigned char *)(argp2);
+ zaxisInqUUID(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_zaxisDefName(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ char *arg2 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefName", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqXbounds", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefName", 2, argv[1] ));
}
- arg2 = (double *)(argp2);
- result = (int)gridInqXbounds(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (char *)(buf2);
+ zaxisDefName(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefYbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqName(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqName", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefYbounds", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqName", 2, argv[1] ));
}
- arg2 = (double *)(argp2);
- gridDefYbounds(arg1,(double const *)arg2);
+ arg2 = (char *)(buf2);
+ zaxisInqName(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqYbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefLongname(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLongname", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqYbounds", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefLongname", 2, argv[1] ));
}
- arg2 = (double *)(argp2);
- result = (int)gridInqYbounds(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (char *)(buf2);
+ zaxisDefLongname(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridDefRowlon(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLongname(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int *arg3 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefRowlon", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLongname", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefRowlon", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","gridDefRowlon", 3, argv[2] ));
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqLongname", 2, argv[1] ));
}
- arg3 = (int *)(argp3);
- gridDefRowlon(arg1,arg2,(int const *)arg3);
+ arg2 = (char *)(buf2);
+ zaxisInqLongname(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridInqRowlon(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefUnits(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqRowlon", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUnits", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gridInqRowlon", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefUnits", 2, argv[1] ));
}
- arg2 = (int *)(argp2);
- gridInqRowlon(arg1,arg2);
+ arg2 = (char *)(buf2);
+ zaxisDefUnits(arg1,(char const *)arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_gridChangeType(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqUnits(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int res2 ;
+ char *buf2 = 0 ;
+ int alloc2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridChangeType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUnits", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridChangeType", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- gridChangeType(arg1,arg2);
+ res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqUnits", 2, argv[1] ));
+ }
+ arg2 = (char *)(buf2);
+ zaxisInqUnits(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisName(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqStdname(int argc, VALUE *argv, VALUE self) {
int arg1 ;
char *arg2 = (char *) 0 ;
int val1 ;
@@ -8627,15 +14459,15 @@ _wrap_zaxisName(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisName", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqStdname", 1, argv[0] ));
}
arg1 = (int)(val1);
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisName", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqStdname", 2, argv[1] ));
}
arg2 = (char *)(buf2);
- zaxisName(arg1,arg2);
+ zaxisInqStdname(arg1,arg2);
if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
fail:
@@ -8645,52 +14477,81 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisCreate(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefDatatype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisCreate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefDatatype", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisCreate", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefDatatype", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (int)zaxisCreate(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ zaxisDefDatatype(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDestroy(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqDatatype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDestroy", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqDatatype", 1, argv[0] ));
}
arg1 = (int)(val1);
- zaxisDestroy(arg1);
+ result = (int)zaxisInqDatatype(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_zaxisDefPositive(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefPositive", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefPositive", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ zaxisDefPositive(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -8698,7 +14559,7 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqType(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqPositive(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -8710,10 +14571,10 @@ _wrap_zaxisInqType(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqPositive", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisInqType(arg1);
+ result = (int)zaxisInqPositive(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -8722,31 +14583,28 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqSize(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefScalar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqSize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefScalar", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisInqSize(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ zaxisDefScalar(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDuplicate(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqScalar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -8758,10 +14616,10 @@ _wrap_zaxisDuplicate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDuplicate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqScalar", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisDuplicate(arg1);
+ result = (int)zaxisInqScalar(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -8770,7 +14628,7 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisResize(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefLtype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -8783,15 +14641,15 @@ _wrap_zaxisResize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisResize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisResize", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 2, argv[1] ));
}
arg2 = (int)(val2);
- zaxisResize(arg1,arg2);
+ zaxisDefLtype(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -8799,35 +14657,22 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisPrint(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLtype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisPrint", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLtype", 1, argv[0] ));
}
arg1 = (int)(val1);
- zaxisPrint(arg1);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_zaxisSize(int argc, VALUE *argv, VALUE self) {
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 0) || (argc > 0)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
- }
- result = (int)zaxisSize();
+ result = (int)zaxisInqLtype(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -8836,57 +14681,28 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisDefLevels(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefLtype2(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevels", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLtype2", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefLevels", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- zaxisDefLevels(arg1,(double const *)arg2);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_zaxisInqLevels(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- double *arg2 = (double *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
-
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevels", 1, argv[0] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLtype2", 2, argv[1] ));
}
- arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqLevels", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- zaxisInqLevels(arg1,arg2);
+ arg2 = (int)(val2);
+ zaxisDefLtype2(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -8894,289 +14710,259 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisDefLevel(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLtype2(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- double arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double val3 ;
- int ecode3 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLtype2", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_double(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","zaxisDefLevel", 3, argv[2] ));
- }
- arg3 = (double)(val3);
- zaxisDefLevel(arg1,arg2,arg3);
- return Qnil;
+ result = (int)zaxisInqLtype2(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqLevel(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefVct(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ double *arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefVct", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefVct", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (double)zaxisInqLevel(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
- return vresult;
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const []","zaxisDefVct", 3, argv[2] ));
+ }
+ arg3 = (double *)(argp3);
+ zaxisDefVct(arg1,arg2,(double const (*))arg3);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefName(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqVct(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefName", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVct", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefName", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisDefName(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","zaxisInqVct", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ zaxisInqVct(arg1,arg2);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefLongname(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqVctSize(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctSize", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefLongname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisDefLongname(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ result = (int)zaxisInqVctSize(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefUnits(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqVctPtr(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ double *result = 0 ;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUnits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctPtr", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefUnits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisDefUnits(arg1,(char const *)arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ result = (double *)zaxisInqVctPtr(arg1);
+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqName(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefLbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqName", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqName", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisInqName(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","zaxisDefLbounds", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ zaxisDefLbounds(arg1,(double const (*))arg2);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqLongname(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqLongname", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisInqLongname(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","zaxisInqLbounds", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqLbounds(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqUnits(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqLbound(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- char *arg2 = (char *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUnits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqUnits", 2, argv[1] ));
- }
- arg2 = (char *)(buf2);
- zaxisInqUnits(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
- return Qnil;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (double)zaxisInqLbound(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefDatatype(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefUbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefDatatype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefDatatype", 2, argv[1] ));
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","zaxisDefUbounds", 2, argv[1] ));
}
- arg2 = (int)(val2);
- zaxisDefDatatype(arg1,arg2);
+ arg2 = (double *)(argp2);
+ zaxisDefUbounds(arg1,(double const (*))arg2);
return Qnil;
fail:
return Qnil;
@@ -9184,22 +14970,30 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqDatatype(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqUbounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqDatatype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisInqDatatype(arg1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","zaxisInqUbounds", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqUbounds(arg1,arg2);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -9208,76 +15002,92 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisDefLtype(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqUbound(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
+ double result;
+ VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 2, argv[1] ));
}
arg2 = (int)(val2);
- zaxisDefLtype(arg1,arg2);
- return Qnil;
+ result = (double)zaxisInqUbound(arg1,arg2);
+ vresult = SWIG_From_double((double)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqLtype(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisDefWeights(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLtype", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefWeights", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisInqLtype(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const []","zaxisDefWeights", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ zaxisDefWeights(arg1,(double const (*))arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqLevelsPtr(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisInqWeights(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double *arg2 ;
int val1 ;
int ecode1 = 0 ;
- double *result = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevelsPtr", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqWeights", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double *)zaxisInqLevelsPtr(arg1);
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double []","zaxisInqWeights", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ result = (int)zaxisInqWeights(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -9285,36 +15095,28 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisDefVct(int argc, VALUE *argv, VALUE self) {
+_wrap_zaxisChangeType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- double *arg3 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefVct", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisChangeType", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefVct", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisChangeType", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","zaxisDefVct", 3, argv[2] ));
- }
- arg3 = (double *)(argp3);
- zaxisDefVct(arg1,arg2,(double const *)arg3);
+ zaxisChangeType(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -9322,7 +15124,7 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqVctSize(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisCreate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -9334,10 +15136,10 @@ _wrap_zaxisInqVctSize(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctSize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCreate", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)zaxisInqVctSize(arg1);
+ result = (int)taxisCreate(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -9346,54 +15148,43 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqVctPtr(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDestroy(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- double *result = 0 ;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctPtr", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDestroy", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (double *)zaxisInqVctPtr(arg1);
- vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
- return vresult;
+ taxisDestroy(arg1);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqLbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDuplicate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDuplicate", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqLbounds", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- result = (int)zaxisInqLbounds(arg1,arg2);
+ result = (int)taxisDuplicate(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -9402,62 +15193,80 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqUbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisCopyTimestep(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqUbounds", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- result = (int)zaxisInqUbounds(arg1,arg2);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ taxisCopyTimestep(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqWeights(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefType(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqWeights", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefType", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqWeights", 2, argv[1] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefType", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ taxisDefType(arg1,arg2);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_taxisInqType(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- arg2 = (double *)(argp2);
- result = (int)zaxisInqWeights(arg1,arg2);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqType", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)taxisInqType(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -9466,134 +15275,124 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisInqLbound(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefVdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
+ void *argp2 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (double)zaxisInqLbound(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
- return vresult;
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int64_t","taxisDefVdate", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","taxisDefVdate", 2, argv[1]));
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ taxisDefVdate(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisInqUbound(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefVtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- double result;
- VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVtime", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVtime", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (double)zaxisInqUbound(arg1,arg2);
- vresult = SWIG_From_double((double)(result));
- return vresult;
+ taxisDefVtime(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefLbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqVdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int64_t result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefLbounds", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- zaxisDefLbounds(arg1,(double const *)arg2);
- return Qnil;
+ result = taxisInqVdate(arg1);
+ vresult = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefUbounds(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqVtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
- int res2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUbounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVtime", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefUbounds", 2, argv[1] ));
- }
- arg2 = (double *)(argp2);
- zaxisDefUbounds(arg1,(double const *)arg2);
- return Qnil;
+ result = (int)taxisInqVtime(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_zaxisDefWeights(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefRdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- double *arg2 = (double *) 0 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- void *argp2 = 0 ;
+ void *argp2 ;
int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
@@ -9601,15 +15400,21 @@ _wrap_zaxisDefWeights(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefWeights", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
- if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefWeights", 2, argv[1] ));
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int64_t","taxisDefRdate", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","taxisDefRdate", 2, argv[1]));
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
}
- arg2 = (double *)(argp2);
- zaxisDefWeights(arg1,(double const *)arg2);
+ taxisDefRdate(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -9617,7 +15422,7 @@ fail:
SWIGINTERN VALUE
-_wrap_zaxisChangeType(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefRtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -9630,15 +15435,15 @@ _wrap_zaxisChangeType(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisChangeType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRtime", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisChangeType", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefRtime", 2, argv[1] ));
}
arg2 = (int)(val2);
- zaxisChangeType(arg1,arg2);
+ taxisDefRtime(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -9646,11 +15451,11 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisCreate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqRdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ int64_t result;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -9658,11 +15463,11 @@ _wrap_taxisCreate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCreate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisCreate(arg1);
- vresult = SWIG_From_int((int)(result));
+ result = taxisInqRdate(arg1);
+ vresult = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
@@ -9670,28 +15475,7 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisDestroy(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDestroy", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- taxisDestroy(arg1);
- return Qnil;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_taxisDuplicate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqRtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -9703,10 +15487,10 @@ _wrap_taxisDuplicate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDuplicate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRtime", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisDuplicate(arg1);
+ result = (int)taxisInqRtime(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -9715,28 +15499,34 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisCopyTimestep(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefFdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ int64_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefFdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisCopyTimestep(arg1,arg2);
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int64_t","taxisDefFdate", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","taxisDefFdate", 2, argv[1]));
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ taxisDefFdate(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -9744,7 +15534,7 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisDefType(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefFtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -9757,15 +15547,15 @@ _wrap_taxisDefType(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefFtime", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefType", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefFtime", 2, argv[1] ));
}
arg2 = (int)(val2);
- taxisDefType(arg1,arg2);
+ taxisDefFtime(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -9773,115 +15563,92 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisDefVdate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqFdate(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int64_t result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVdate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqFdate", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVdate", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisDefVdate(arg1,arg2);
- return Qnil;
+ result = taxisInqFdate(arg1);
+ vresult = SWIG_NewPointerObj((int64_t *)memcpy((int64_t *)calloc(1,sizeof(int64_t)),&result,sizeof(int64_t)), SWIGTYPE_p_int64_t, SWIG_POINTER_OWN | 0 );
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisDefVtime(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqFtime(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVtime", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqFtime", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVtime", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisDefVtime(arg1,arg2);
- return Qnil;
+ result = (int)taxisInqFtime(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisDefRdate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisHasBounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRdate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisHasBounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefRdate", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisDefRdate(arg1,arg2);
- return Qnil;
+ result = (int)taxisHasBounds(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisDefRtime(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisWithBounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRtime", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisWithBounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefRtime", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisDefRtime(arg1,arg2);
+ taxisWithBounds(arg1);
return Qnil;
fail:
return Qnil;
@@ -9889,24 +15656,21 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisHasBounds(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDeleteBounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisHasBounds", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDeleteBounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisHasBounds(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ taxisDeleteBounds(arg1);
+ return Qnil;
fail:
return Qnil;
}
@@ -9915,14 +15679,14 @@ fail:
SWIGINTERN VALUE
_wrap_taxisDefVdateBounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- int arg3 ;
+ int64_t arg2 ;
+ int64_t arg3 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int val3 ;
- int ecode3 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ void *argp3 ;
+ int res3 = 0 ;
if ((argc < 3) || (argc > 3)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
@@ -9932,16 +15696,28 @@ _wrap_taxisDefVdateBounds(int argc, VALUE *argv, VALUE self) {
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- ecode3 = SWIG_AsVal_int(argv[2], &val3);
- if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 3, argv[2] ));
- }
- arg3 = (int)(val3);
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int64_t","taxisDefVdateBounds", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","taxisDefVdateBounds", 2, argv[1]));
+ } else {
+ arg2 = *((int64_t *)(argp2));
+ }
+ }
+ {
+ res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_int64_t, 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int64_t","taxisDefVdateBounds", 3, argv[2] ));
+ }
+ if (!argp3) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int64_t","taxisDefVdateBounds", 3, argv[2]));
+ } else {
+ arg3 = *((int64_t *)(argp3));
+ }
+ }
taxisDefVdateBounds(arg1,arg2,arg3);
return Qnil;
fail:
@@ -9989,8 +15765,8 @@ fail:
SWIGINTERN VALUE
_wrap_taxisInqVdateBounds(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int *arg2 = (int *) 0 ;
- int *arg3 = (int *) 0 ;
+ int64_t *arg2 = (int64_t *) 0 ;
+ int64_t *arg3 = (int64_t *) 0 ;
int val1 ;
int ecode1 = 0 ;
void *argp2 = 0 ;
@@ -10006,16 +15782,16 @@ _wrap_taxisInqVdateBounds(int argc, VALUE *argv, VALUE self) {
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVdateBounds", 1, argv[0] ));
}
arg1 = (int)(val1);
- res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int64_t, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","taxisInqVdateBounds", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int64_t *","taxisInqVdateBounds", 2, argv[1] ));
}
- arg2 = (int *)(argp2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ arg2 = (int64_t *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int64_t, 0 | 0 );
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","taxisInqVdateBounds", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int64_t *","taxisInqVdateBounds", 3, argv[2] ));
}
- arg3 = (int *)(argp3);
+ arg3 = (int64_t *)(argp3);
taxisInqVdateBounds(arg1,arg2,arg3);
return Qnil;
fail:
@@ -10090,36 +15866,31 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisDefTunit(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqCalendar(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefTunit", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqCalendar", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefTunit", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- taxisDefTunit(arg1,arg2);
- return Qnil;
+ result = (int)taxisInqCalendar(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisDefNumavg(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefTunit(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
int val1 ;
@@ -10132,15 +15903,15 @@ _wrap_taxisDefNumavg(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefTunit", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefTunit", 2, argv[1] ));
}
arg2 = (int)(val2);
- taxisDefNumavg(arg1,arg2);
+ taxisDefTunit(arg1,arg2);
return Qnil;
fail:
return Qnil;
@@ -10148,7 +15919,7 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisInqType(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqTunit(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -10160,10 +15931,10 @@ _wrap_taxisInqType(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqType", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqTunit", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqType(arg1);
+ result = (int)taxisInqTunit(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -10172,55 +15943,36 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisInqVdate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefForecastTunit(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVdate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefForecastTunit", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqVdate(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
-fail:
- return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_taxisInqVtime(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int val1 ;
- int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
-
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVtime", 1, argv[0] ));
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefForecastTunit", 2, argv[1] ));
}
- arg1 = (int)(val1);
- result = (int)taxisInqVtime(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ arg2 = (int)(val2);
+ taxisDefForecastTunit(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisInqRdate(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqForecastTunit(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
@@ -10232,10 +15984,10 @@ _wrap_taxisInqRdate(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRdate", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqForecastTunit", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqRdate(arg1);
+ result = (int)taxisInqForecastTunit(arg1);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -10244,35 +15996,40 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisInqRtime(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefForecastPeriod(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ double arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ double val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRtime", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefForecastPeriod", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqRtime(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_double(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","taxisDefForecastPeriod", 2, argv[1] ));
+ }
+ arg2 = (double)(val2);
+ taxisDefForecastPeriod(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_taxisInqCalendar(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisInqForecastPeriod(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int val1 ;
int ecode1 = 0 ;
- int result;
+ double result;
VALUE vresult = Qnil;
if ((argc < 1) || (argc > 1)) {
@@ -10280,11 +16037,11 @@ _wrap_taxisInqCalendar(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqCalendar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqForecastPeriod", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqCalendar(arg1);
- vresult = SWIG_From_int((int)(result));
+ result = (double)taxisInqForecastPeriod(arg1);
+ vresult = SWIG_From_double((double)(result));
return vresult;
fail:
return Qnil;
@@ -10292,24 +16049,29 @@ fail:
SWIGINTERN VALUE
-_wrap_taxisInqTunit(int argc, VALUE *argv, VALUE self) {
+_wrap_taxisDefNumavg(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
- int result;
- VALUE vresult = Qnil;
+ int val2 ;
+ int ecode2 = 0 ;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqTunit", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)taxisInqTunit(arg1);
- vresult = SWIG_From_int((int)(result));
- return vresult;
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ taxisDefNumavg(arg1,arg2);
+ return Qnil;
fail:
return Qnil;
}
@@ -10656,10 +16418,10 @@ _wrap_modelInq(int argc, VALUE *argv, VALUE self) {
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","modelInq", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","modelInq", 3, argv[2] ));
}
arg3 = (char *)(buf3);
- result = (int)modelInq(arg1,arg2,arg3);
+ result = (int)modelInq(arg1,arg2,(char const *)arg3);
vresult = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return vresult;
@@ -10742,33 +16504,30 @@ fail:
SWIGINTERN VALUE
-_wrap_tableWriteC(int argc, VALUE *argv, VALUE self) {
- char *arg1 = (char *) 0 ;
+_wrap_tableFWriteC(int argc, VALUE *argv, VALUE self) {
+ FILE *arg1 = (FILE *) 0 ;
int arg2 ;
- int res1 ;
- char *buf1 = 0 ;
- int alloc1 = 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","tableWriteC", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","tableFWriteC", 1, argv[0] ));
}
- arg1 = (char *)(buf1);
+ arg1 = (FILE *)(argp1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableWriteC", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableFWriteC", 2, argv[1] ));
}
arg2 = (int)(val2);
- tableWriteC((char const *)arg1,arg2);
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ tableFWriteC(arg1,arg2);
return Qnil;
fail:
- if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
return Qnil;
}
@@ -10899,68 +16658,6 @@ fail:
}
-SWIGINTERN VALUE
-_wrap_tableDefEntry(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
- char *arg4 = (char *) 0 ;
- char *arg5 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int res4 ;
- char *buf4 = 0 ;
- int alloc4 = 0 ;
- int res5 ;
- char *buf5 = 0 ;
- int alloc5 = 0 ;
-
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
- }
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableDefEntry", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableDefEntry", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
- if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 4, argv[3] ));
- }
- arg4 = (char *)(buf4);
- res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
- if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 5, argv[4] ));
- }
- arg5 = (char *)(buf5);
- tableDefEntry(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
- return Qnil;
-fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
- if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
- return Qnil;
-}
-
-
SWIGINTERN VALUE
_wrap_tableInq(int argc, VALUE *argv, VALUE self) {
int arg1 ;
@@ -11069,265 +16766,398 @@ fail:
SWIGINTERN VALUE
-_wrap_tableInqPar(int argc, VALUE *argv, VALUE self) {
+_wrap_tableInqEntry(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
+ int arg3 ;
char *arg4 = (char *) 0 ;
char *arg5 = (char *) 0 ;
+ char *arg6 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
int res4 ;
char *buf4 = 0 ;
int alloc4 = 0 ;
int res5 ;
char *buf5 = 0 ;
int alloc5 = 0 ;
+ int res6 ;
+ char *buf6 = 0 ;
+ int alloc6 = 0 ;
- if ((argc < 5) || (argc > 5)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+ if ((argc < 6) || (argc > 6)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqPar", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqEntry", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqPar", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqEntry", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqPar", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","tableInqEntry", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
if (!SWIG_IsOK(res4)) {
- SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","tableInqPar", 4, argv[3] ));
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","tableInqEntry", 4, argv[3] ));
}
arg4 = (char *)(buf4);
res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
if (!SWIG_IsOK(res5)) {
- SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","tableInqPar", 5, argv[4] ));
+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","tableInqEntry", 5, argv[4] ));
}
arg5 = (char *)(buf5);
- tableInqPar(arg1,arg2,arg3,arg4,arg5);
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ res6 = SWIG_AsCharPtrAndSize(argv[5], &buf6, NULL, &alloc6);
+ if (!SWIG_IsOK(res6)) {
+ SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char *","tableInqEntry", 6, argv[5] ));
+ }
+ arg6 = (char *)(buf6);
+ tableInqEntry(arg1,arg2,arg3,arg4,arg5,arg6);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
return Qnil;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
+ if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamDefHistory(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int arg2 ;
+ char *arg3 = (char *) 0 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
+ int res3 ;
+ char *buf3 = 0 ;
+ int alloc3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefHistory", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefHistory", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","streamDefHistory", 3, argv[2] ));
+ }
+ arg3 = (char *)(buf3);
+ streamDefHistory(arg1,arg2,(char const *)arg3);
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+fail:
+ if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_streamInqHistorySize(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistorySize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)streamInqHistorySize(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
return Qnil;
}
SWIGINTERN VALUE
-_wrap_tableInqParCode(int argc, VALUE *argv, VALUE self) {
+_wrap_streamInqHistoryString(int argc, VALUE *argv, VALUE self) {
int arg1 ;
char *arg2 = (char *) 0 ;
- int *arg3 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int res2 ;
char *buf2 = 0 ;
int alloc2 = 0 ;
- void *argp3 = 0 ;
- int res3 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParCode", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistoryString", 1, argv[0] ));
}
arg1 = (int)(val1);
res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","tableInqParCode", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","streamInqHistoryString", 2, argv[1] ));
}
arg2 = (char *)(buf2);
- res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","tableInqParCode", 3, argv[2] ));
+ streamInqHistoryString(arg1,arg2);
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+fail:
+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_subtypeCreate(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
- arg3 = (int *)(argp3);
- result = (int)tableInqParCode(arg1,arg2,arg3);
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeCreate", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)subtypeCreate(arg1);
vresult = SWIG_From_int((int)(result));
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return vresult;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_tableInqParName(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypePrint(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypePrint", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ subtypePrint(arg1);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_subtypeCompare(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParName", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeCompare", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParName", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","subtypeCompare", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParName", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParName(arg1,arg2,arg3);
+ result = (int)subtypeCompare(arg1,arg2);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_tableInqParLongname(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypeInqSize(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ }
+ ecode1 = SWIG_AsVal_int(argv[0], &val1);
+ if (!SWIG_IsOK(ecode1)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeInqSize", 1, argv[0] ));
+ }
+ arg1 = (int)(val1);
+ result = (int)subtypeInqSize(arg1);
+ vresult = SWIG_From_int((int)(result));
+ return vresult;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_subtypeInqActiveIndex(int argc, VALUE *argv, VALUE self) {
+ int arg1 ;
+ int val1 ;
+ int ecode1 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 1) || (argc > 1)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParLongname", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeInqActiveIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParLongname", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParLongname", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParLongname(arg1,arg2,arg3);
+ result = (int)subtypeInqActiveIndex(arg1);
vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return vresult;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_tableInqParUnits(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypeDefActiveIndex(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
- char *arg3 = (char *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- int res3 ;
- char *buf3 = 0 ;
- int alloc3 = 0 ;
- int result;
- VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParUnits", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeDefActiveIndex", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParUnits", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","subtypeDefActiveIndex", 2, argv[1] ));
}
arg2 = (int)(val2);
- res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
- if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParUnits", 3, argv[2] ));
- }
- arg3 = (char *)(buf3);
- result = (int)tableInqParUnits(arg1,arg2,arg3);
- vresult = SWIG_From_int((int)(result));
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return vresult;
+ subtypeDefActiveIndex(arg1,arg2);
+ return Qnil;
fail:
- if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
}
SWIGINTERN VALUE
-_wrap_tableInqParNamePtr(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
+_wrap_keyValuePair(int argc, VALUE *argv, VALUE self) {
+ char *arg1 = (char *) 0 ;
int arg2 ;
- int val1 ;
- int ecode1 = 0 ;
+ int res1 ;
+ char *buf1 = 0 ;
+ int alloc1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- char *result = 0 ;
+ subtype_query_t result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParNamePtr", 1, argv[0] ));
- }
- arg1 = (int)(val1);
+ res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","keyValuePair", 1, argv[0] ));
+ }
+ arg1 = (char *)(buf1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParNamePtr", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","keyValuePair", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (char *)tableInqParNamePtr(arg1,arg2);
- vresult = SWIG_FromCharPtr((const char *)result);
+ result = keyValuePair((char const *)arg1,arg2);
+ vresult = SWIG_NewPointerObj((subtype_query_t *)memcpy((subtype_query_t *)calloc(1,sizeof(subtype_query_t)),&result,sizeof(subtype_query_t)), SWIGTYPE_p_subtype_query_t, SWIG_POINTER_OWN | 0 );
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return vresult;
+fail:
+ if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_matchAND(int argc, VALUE *argv, VALUE self) {
+ subtype_query_t arg1 ;
+ subtype_query_t arg2 ;
+ void *argp1 ;
+ int res1 = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ subtype_query_t result;
+ VALUE vresult = Qnil;
+
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ }
+ {
+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "subtype_query_t","matchAND", 1, argv[0] ));
+ }
+ if (!argp1) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "subtype_query_t","matchAND", 1, argv[0]));
+ } else {
+ arg1 = *((subtype_query_t *)(argp1));
+ }
+ }
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "subtype_query_t","matchAND", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "subtype_query_t","matchAND", 2, argv[1]));
+ } else {
+ arg2 = *((subtype_query_t *)(argp2));
+ }
+ }
+ result = matchAND(arg1,arg2);
+ vresult = SWIG_NewPointerObj((subtype_query_t *)memcpy((subtype_query_t *)calloc(1,sizeof(subtype_query_t)),&result,sizeof(subtype_query_t)), SWIGTYPE_p_subtype_query_t, SWIG_POINTER_OWN | 0 );
return vresult;
fail:
return Qnil;
@@ -11335,14 +17165,14 @@ fail:
SWIGINTERN VALUE
-_wrap_tableInqParLongnamePtr(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypeInqSubEntry(int argc, VALUE *argv, VALUE self) {
int arg1 ;
- int arg2 ;
+ subtype_query_t arg2 ;
int val1 ;
int ecode1 = 0 ;
- int val2 ;
- int ecode2 = 0 ;
- char *result = 0 ;
+ void *argp2 ;
+ int res2 = 0 ;
+ int result;
VALUE vresult = Qnil;
if ((argc < 2) || (argc > 2)) {
@@ -11350,16 +17180,22 @@ _wrap_tableInqParLongnamePtr(int argc, VALUE *argv, VALUE self) {
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParLongnamePtr", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeInqSubEntry", 1, argv[0] ));
}
arg1 = (int)(val1);
- ecode2 = SWIG_AsVal_int(argv[1], &val2);
- if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParLongnamePtr", 2, argv[1] ));
- }
- arg2 = (int)(val2);
- result = (char *)tableInqParLongnamePtr(arg1,arg2);
- vresult = SWIG_FromCharPtr((const char *)result);
+ {
+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_subtype_query_t, 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "subtype_query_t","subtypeInqSubEntry", 2, argv[1] ));
+ }
+ if (!argp2) {
+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "subtype_query_t","subtypeInqSubEntry", 2, argv[1]));
+ } else {
+ arg2 = *((subtype_query_t *)(argp2));
+ }
+ }
+ result = (int)subtypeInqSubEntry(arg1,arg2);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -11367,31 +17203,39 @@ fail:
SWIGINTERN VALUE
-_wrap_tableInqParUnitsPtr(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypeInqTile(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
+ int arg3 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
int ecode2 = 0 ;
- char *result = 0 ;
+ int val3 ;
+ int ecode3 = 0 ;
+ int result;
VALUE vresult = Qnil;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParUnitsPtr", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeInqTile", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParUnitsPtr", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","subtypeInqTile", 2, argv[1] ));
}
arg2 = (int)(val2);
- result = (char *)tableInqParUnitsPtr(arg1,arg2);
- vresult = SWIG_FromCharPtr((const char *)result);
+ ecode3 = SWIG_AsVal_int(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","subtypeInqTile", 3, argv[2] ));
+ }
+ arg3 = (int)(val3);
+ result = (int)subtypeInqTile(arg1,arg2,arg3);
+ vresult = SWIG_From_int((int)(result));
return vresult;
fail:
return Qnil;
@@ -11399,10 +17243,11 @@ fail:
SWIGINTERN VALUE
-_wrap_streamDefHistory(int argc, VALUE *argv, VALUE self) {
+_wrap_subtypeInqAttribute(int argc, VALUE *argv, VALUE self) {
int arg1 ;
int arg2 ;
char *arg3 = (char *) 0 ;
+ int *arg4 = (int *) 0 ;
int val1 ;
int ecode1 = 0 ;
int val2 ;
@@ -11410,28 +17255,38 @@ _wrap_streamDefHistory(int argc, VALUE *argv, VALUE self) {
int res3 ;
char *buf3 = 0 ;
int alloc3 = 0 ;
+ void *argp4 = 0 ;
+ int res4 = 0 ;
+ int result;
+ VALUE vresult = Qnil;
- if ((argc < 3) || (argc > 3)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ if ((argc < 4) || (argc > 4)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefHistory", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","subtypeInqAttribute", 1, argv[0] ));
}
arg1 = (int)(val1);
ecode2 = SWIG_AsVal_int(argv[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefHistory", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","subtypeInqAttribute", 2, argv[1] ));
}
arg2 = (int)(val2);
res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","streamDefHistory", 3, argv[2] ));
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","subtypeInqAttribute", 3, argv[2] ));
}
arg3 = (char *)(buf3);
- streamDefHistory(arg1,arg2,(char const *)arg3);
+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res4)) {
+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","subtypeInqAttribute", 4, argv[3] ));
+ }
+ arg4 = (int *)(argp4);
+ result = (int)subtypeInqAttribute(arg1,arg2,(char const *)arg3,arg4);
+ vresult = SWIG_From_int((int)(result));
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
- return Qnil;
+ return vresult;
fail:
if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
return Qnil;
@@ -11439,22 +17294,30 @@ fail:
SWIGINTERN VALUE
-_wrap_streamInqHistorySize(int argc, VALUE *argv, VALUE self) {
+_wrap_vlistInqVarSubtype(int argc, VALUE *argv, VALUE self) {
int arg1 ;
+ int arg2 ;
int val1 ;
int ecode1 = 0 ;
+ int val2 ;
+ int ecode2 = 0 ;
int result;
VALUE vresult = Qnil;
- if ((argc < 1) || (argc > 1)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+ if ((argc < 2) || (argc > 2)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
}
ecode1 = SWIG_AsVal_int(argv[0], &val1);
if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistorySize", 1, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarSubtype", 1, argv[0] ));
}
arg1 = (int)(val1);
- result = (int)streamInqHistorySize(arg1);
+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
+ if (!SWIG_IsOK(ecode2)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarSubtype", 2, argv[1] ));
+ }
+ arg2 = (int)(val2);
+ result = (int)vlistInqVarSubtype(arg1,arg2);
vresult = SWIG_From_int((int)(result));
return vresult;
fail:
@@ -11463,33 +17326,75 @@ fail:
SWIGINTERN VALUE
-_wrap_streamInqHistoryString(int argc, VALUE *argv, VALUE self) {
- int arg1 ;
- char *arg2 = (char *) 0 ;
- int val1 ;
- int ecode1 = 0 ;
- int res2 ;
- char *buf2 = 0 ;
- int alloc2 = 0 ;
+_wrap_gribapiLibraryVersion(int argc, VALUE *argv, VALUE self) {
+ int *arg1 = (int *) 0 ;
+ int *arg2 = (int *) 0 ;
+ int *arg3 = (int *) 0 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ void *argp3 = 0 ;
+ int res3 = 0 ;
- if ((argc < 2) || (argc > 2)) {
- rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
}
- ecode1 = SWIG_AsVal_int(argv[0], &val1);
- if (!SWIG_IsOK(ecode1)) {
- SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistoryString", 1, argv[0] ));
- }
- arg1 = (int)(val1);
- res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int *","gribapiLibraryVersion", 1, argv[0] ));
+ }
+ arg1 = (int *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","streamInqHistoryString", 2, argv[1] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gribapiLibraryVersion", 2, argv[1] ));
}
- arg2 = (char *)(buf2);
- streamInqHistoryString(arg1,arg2);
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+ arg2 = (int *)(argp2);
+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );
+ if (!SWIG_IsOK(res3)) {
+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","gribapiLibraryVersion", 3, argv[2] ));
+ }
+ arg3 = (int *)(argp3);
+ gribapiLibraryVersion(arg1,arg2,arg3);
+ return Qnil;
+fail:
+ return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_gaussianLatitudes(int argc, VALUE *argv, VALUE self) {
+ double *arg1 = (double *) 0 ;
+ double *arg2 = (double *) 0 ;
+ size_t arg3 ;
+ void *argp1 = 0 ;
+ int res1 = 0 ;
+ void *argp2 = 0 ;
+ int res2 = 0 ;
+ size_t val3 ;
+ int ecode3 = 0 ;
+
+ if ((argc < 3) || (argc > 3)) {
+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+ }
+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res1)) {
+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "double *","gaussianLatitudes", 1, argv[0] ));
+ }
+ arg1 = (double *)(argp1);
+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );
+ if (!SWIG_IsOK(res2)) {
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gaussianLatitudes", 2, argv[1] ));
+ }
+ arg2 = (double *)(argp2);
+ ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+ if (!SWIG_IsOK(ecode3)) {
+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","gaussianLatitudes", 3, argv[2] ));
+ }
+ arg3 = (size_t)(val3);
+ gaussianLatitudes(arg1,arg2,arg3);
return Qnil;
fail:
- if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
return Qnil;
}
@@ -11497,32 +17402,84 @@ fail:
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+static swig_type_info _swigt__p_CdiGribIterator = {"_p_CdiGribIterator", "struct CdiGribIterator *|CdiGribIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CdiIterator = {"_p_CdiIterator", "struct CdiIterator *|CdiIterator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_CdiParam = {"_p_CdiParam", "struct CdiParam *|CdiParam *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_a_10__int = {"_p_a_10__int", "int (*)[10]", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_a_2__int = {"_p_a_2__int", "int (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int64_t = {"_p_int64_t", "int64_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_subtype_query_t = {"_p_subtype_query_t", "subtype_query_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info *swig_type_initial[] = {
+ &_swigt__p_CdiGribIterator,
+ &_swigt__p_CdiIterator,
+ &_swigt__p_CdiParam,
+ &_swigt__p_FILE,
+ &_swigt__p_a_10__int,
+ &_swigt__p_a_2__int,
&_swigt__p_char,
&_swigt__p_double,
&_swigt__p_float,
&_swigt__p_int,
+ &_swigt__p_int64_t,
+ &_swigt__p_long,
&_swigt__p_off_t,
+ &_swigt__p_p_char,
+ &_swigt__p_p_p_char,
+ &_swigt__p_size_t,
+ &_swigt__p_subtype_query_t,
+ &_swigt__p_unsigned_char,
};
+static swig_cast_info _swigc__p_CdiGribIterator[] = { {&_swigt__p_CdiGribIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CdiIterator[] = { {&_swigt__p_CdiIterator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_CdiParam[] = { {&_swigt__p_CdiParam, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_a_10__int[] = { {&_swigt__p_a_10__int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_a_2__int[] = { {&_swigt__p_a_2__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int64_t[] = { {&_swigt__p_int64_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_p_char[] = { {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_subtype_query_t[] = { {&_swigt__p_subtype_query_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info *swig_cast_initial[] = {
+ _swigc__p_CdiGribIterator,
+ _swigc__p_CdiIterator,
+ _swigc__p_CdiParam,
+ _swigc__p_FILE,
+ _swigc__p_a_10__int,
+ _swigc__p_a_2__int,
_swigc__p_char,
_swigc__p_double,
_swigc__p_float,
_swigc__p_int,
+ _swigc__p_int64_t,
+ _swigc__p_long,
_swigc__p_off_t,
+ _swigc__p_p_char,
+ _swigc__p_p_p_char,
+ _swigc__p_size_t,
+ _swigc__p_subtype_query_t,
+ _swigc__p_unsigned_char,
};
@@ -11530,18 +17487,18 @@ static swig_cast_info *swig_cast_initial[] = {
/* -----------------------------------------------------------------------------
* Type initialization:
- * This problem is tough by the requirement that no dynamic
- * memory is used. Also, since swig_type_info structures store pointers to
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
* swig_cast_info structures and swig_cast_info structures store pointers back
- * to swig_type_info structures, we need some lookup code at initialization.
- * The idea is that swig generates all the structures that are needed.
- * The runtime then collects these partially filled structures.
- * The SWIG_InitializeModule function takes these initial arrays out of
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
* swig_module, and does all the lookup, filling in the swig_module.types
* array with the correct data and linking the correct swig_cast_info
* structures together.
*
- * The generated swig_type_info structures are assigned staticly to an initial
+ * The generated swig_type_info structures are assigned statically to an initial
* array. We just loop through that array, and handle each type individually.
* First we lookup if this type has been already loaded, and if so, use the
* loaded structure instead of the generated one. Then we have to fill in the
@@ -11551,17 +17508,17 @@ static swig_cast_info *swig_cast_initial[] = {
* a column is one of the swig_cast_info structures for that type.
* The cast_initial array is actually an array of arrays, because each row has
* a variable number of columns. So to actually build the cast linked list,
- * we find the array of casts associated with the type, and loop through it
+ * we find the array of casts associated with the type, and loop through it
* adding the casts to the list. The one last trick we need to do is making
* sure the type pointer in the swig_cast_info struct is correct.
*
- * First off, we lookup the cast->type name to see if it is already loaded.
+ * First off, we lookup the cast->type name to see if it is already loaded.
* There are three cases to handle:
* 1) If the cast->type has already been loaded AND the type we are adding
* casting info to has not been loaded (it is in this module), THEN we
* replace the cast->type pointer with the type pointer that has already
* been loaded.
- * 2) If BOTH types (the one we are adding casting info to, and the
+ * 2) If BOTH types (the one we are adding casting info to, and the
* cast->type) are loaded, THEN the cast info has already been loaded by
* the previous module so we just ignore it.
* 3) Finally, if cast->type has not already been loaded, then we add that
@@ -11585,9 +17542,7 @@ SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
size_t i;
swig_module_info *module_head, *iter;
- int found, init;
-
- clientdata = clientdata;
+ int init;
/* check to see if the circular list has been setup, if not, set it up */
if (swig_module.next==0) {
@@ -11606,27 +17561,23 @@ SWIG_InitializeModule(void *clientdata) {
/* This is the first module loaded for this interpreter */
/* so set the swig module into the interpreter */
SWIG_SetModule(clientdata, &swig_module);
- module_head = &swig_module;
} else {
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
- found=0;
iter=module_head;
do {
if (iter==&swig_module) {
- found=1;
- break;
+ /* Our module is already in the list, so there's nothing more to do. */
+ return;
}
iter=iter->next;
} while (iter!= module_head);
- /* if the is found in the list, then all is done and we may leave */
- if (found) return;
- /* otherwise we must add out module into the list */
+ /* otherwise we must add our module into the list */
swig_module.next = module_head->next;
module_head->next = &swig_module;
}
- /* When multiple interpeters are used, a module could have already been initialized in
+ /* When multiple interpreters are used, a module could have already been initialized in
a different interpreter, but not yet have a pointer in this interpreter.
In this case, we do not want to continue adding types... everything should be
set up already */
@@ -11634,15 +17585,15 @@ SWIG_InitializeModule(void *clientdata) {
/* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
- printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+ printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
for (i = 0; i < swig_module.size; ++i) {
swig_type_info *type = 0;
swig_type_info *ret;
swig_cast_info *cast;
-
+
#ifdef SWIGRUNTIME_DEBUG
- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
/* if there is another module already loaded */
@@ -11667,7 +17618,7 @@ SWIG_InitializeModule(void *clientdata) {
/* Insert casting types */
cast = swig_module.cast_initial[i];
while (cast->type) {
-
+
/* Don't need to add information already in the list */
ret = 0;
#ifdef SWIGRUNTIME_DEBUG
@@ -11718,7 +17669,7 @@ SWIG_InitializeModule(void *clientdata) {
for (i = 0; i < swig_module.size; ++i) {
int j = 0;
swig_cast_info *cast = swig_module.cast_initial[i];
- printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+ printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
while (cast->type) {
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
cast++;
@@ -11783,74 +17734,96 @@ SWIGEXPORT void Init_CdiLib(void) {
}
SWIG_RubyInitializeTrackings();
+ rb_define_const(mCdiLib, "CDI_MAX_NAME", SWIG_From_int((int)(256)));
rb_define_const(mCdiLib, "CDI_UNDEFID", SWIG_From_int((int)(-1)));
rb_define_const(mCdiLib, "CDI_GLOBAL", SWIG_From_int((int)(-1)));
rb_define_const(mCdiLib, "CDI_BIGENDIAN", SWIG_From_int((int)(0)));
rb_define_const(mCdiLib, "CDI_LITTLEENDIAN", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_PDPENDIAN", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_REAL", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_COMP", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_BOTH", SWIG_From_int((int)(3)));
rb_define_const(mCdiLib, "CDI_NOERR", SWIG_From_int((int)(0)));
+ rb_define_const(mCdiLib, "CDI_EEOF", SWIG_From_int((int)(-1)));
+ rb_define_const(mCdiLib, "CDI_ETMOF", SWIG_From_int((int)(-9)));
rb_define_const(mCdiLib, "CDI_ESYSTEM", SWIG_From_int((int)(-10)));
rb_define_const(mCdiLib, "CDI_EINVAL", SWIG_From_int((int)(-20)));
- rb_define_const(mCdiLib, "CDI_EUFTYPE", SWIG_From_int((int)(-21)));
- rb_define_const(mCdiLib, "CDI_ELIBNAVAIL", SWIG_From_int((int)(-22)));
- rb_define_const(mCdiLib, "CDI_EUFSTRUCT", SWIG_From_int((int)(-23)));
- rb_define_const(mCdiLib, "CDI_EUNC4", SWIG_From_int((int)(-24)));
- rb_define_const(mCdiLib, "FILETYPE_GRB", SWIG_From_int((int)(1)));
- rb_define_const(mCdiLib, "FILETYPE_GRB2", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "FILETYPE_NC", SWIG_From_int((int)(3)));
- rb_define_const(mCdiLib, "FILETYPE_NC2", SWIG_From_int((int)(4)));
- rb_define_const(mCdiLib, "FILETYPE_NC4", SWIG_From_int((int)(5)));
- rb_define_const(mCdiLib, "FILETYPE_SRV", SWIG_From_int((int)(6)));
- rb_define_const(mCdiLib, "FILETYPE_EXT", SWIG_From_int((int)(7)));
- rb_define_const(mCdiLib, "FILETYPE_IEG", SWIG_From_int((int)(8)));
- rb_define_const(mCdiLib, "COMPRESS_NONE", SWIG_From_int((int)(0)));
- rb_define_const(mCdiLib, "COMPRESS_SZIP", SWIG_From_int((int)(1)));
- rb_define_const(mCdiLib, "COMPRESS_GZIP", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "COMPRESS_BZIP2", SWIG_From_int((int)(3)));
- rb_define_const(mCdiLib, "COMPRESS_ZIP", SWIG_From_int((int)(4)));
- rb_define_const(mCdiLib, "DATATYPE_PACK", SWIG_From_int((int)(0)));
- rb_define_const(mCdiLib, "DATATYPE_PACK1", SWIG_From_int((int)(1)));
- rb_define_const(mCdiLib, "DATATYPE_PACK2", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "DATATYPE_PACK3", SWIG_From_int((int)(3)));
- rb_define_const(mCdiLib, "DATATYPE_PACK4", SWIG_From_int((int)(4)));
- rb_define_const(mCdiLib, "DATATYPE_PACK5", SWIG_From_int((int)(5)));
- rb_define_const(mCdiLib, "DATATYPE_PACK6", SWIG_From_int((int)(6)));
- rb_define_const(mCdiLib, "DATATYPE_PACK7", SWIG_From_int((int)(7)));
- rb_define_const(mCdiLib, "DATATYPE_PACK8", SWIG_From_int((int)(8)));
- rb_define_const(mCdiLib, "DATATYPE_PACK9", SWIG_From_int((int)(9)));
- rb_define_const(mCdiLib, "DATATYPE_PACK10", SWIG_From_int((int)(10)));
- rb_define_const(mCdiLib, "DATATYPE_PACK11", SWIG_From_int((int)(11)));
- rb_define_const(mCdiLib, "DATATYPE_PACK12", SWIG_From_int((int)(12)));
- rb_define_const(mCdiLib, "DATATYPE_PACK13", SWIG_From_int((int)(13)));
- rb_define_const(mCdiLib, "DATATYPE_PACK14", SWIG_From_int((int)(14)));
- rb_define_const(mCdiLib, "DATATYPE_PACK15", SWIG_From_int((int)(15)));
- rb_define_const(mCdiLib, "DATATYPE_PACK16", SWIG_From_int((int)(16)));
- rb_define_const(mCdiLib, "DATATYPE_PACK17", SWIG_From_int((int)(17)));
- rb_define_const(mCdiLib, "DATATYPE_PACK18", SWIG_From_int((int)(18)));
- rb_define_const(mCdiLib, "DATATYPE_PACK19", SWIG_From_int((int)(19)));
- rb_define_const(mCdiLib, "DATATYPE_PACK20", SWIG_From_int((int)(20)));
- rb_define_const(mCdiLib, "DATATYPE_PACK21", SWIG_From_int((int)(21)));
- rb_define_const(mCdiLib, "DATATYPE_PACK22", SWIG_From_int((int)(22)));
- rb_define_const(mCdiLib, "DATATYPE_PACK23", SWIG_From_int((int)(23)));
- rb_define_const(mCdiLib, "DATATYPE_PACK24", SWIG_From_int((int)(24)));
- rb_define_const(mCdiLib, "DATATYPE_PACK25", SWIG_From_int((int)(25)));
- rb_define_const(mCdiLib, "DATATYPE_PACK26", SWIG_From_int((int)(26)));
- rb_define_const(mCdiLib, "DATATYPE_PACK27", SWIG_From_int((int)(27)));
- rb_define_const(mCdiLib, "DATATYPE_PACK28", SWIG_From_int((int)(28)));
- rb_define_const(mCdiLib, "DATATYPE_PACK29", SWIG_From_int((int)(29)));
- rb_define_const(mCdiLib, "DATATYPE_PACK30", SWIG_From_int((int)(30)));
- rb_define_const(mCdiLib, "DATATYPE_PACK31", SWIG_From_int((int)(31)));
- rb_define_const(mCdiLib, "DATATYPE_PACK32", SWIG_From_int((int)(32)));
- rb_define_const(mCdiLib, "DATATYPE_FLT32", SWIG_From_int((int)(132)));
- rb_define_const(mCdiLib, "DATATYPE_FLT64", SWIG_From_int((int)(164)));
- rb_define_const(mCdiLib, "DATATYPE_INT8", SWIG_From_int((int)(208)));
- rb_define_const(mCdiLib, "DATATYPE_INT16", SWIG_From_int((int)(216)));
- rb_define_const(mCdiLib, "DATATYPE_INT32", SWIG_From_int((int)(232)));
- rb_define_const(mCdiLib, "DATATYPE_UINT8", SWIG_From_int((int)(308)));
- rb_define_const(mCdiLib, "DATATYPE_UINT16", SWIG_From_int((int)(316)));
- rb_define_const(mCdiLib, "DATATYPE_UINT32", SWIG_From_int((int)(332)));
- rb_define_const(mCdiLib, "DATATYPE_INT", SWIG_From_int((int)(251)));
- rb_define_const(mCdiLib, "DATATYPE_FLT", SWIG_From_int((int)(252)));
- rb_define_const(mCdiLib, "DATATYPE_TXT", SWIG_From_int((int)(253)));
+ rb_define_const(mCdiLib, "CDI_EISDIR", SWIG_From_int((int)(-21)));
+ rb_define_const(mCdiLib, "CDI_EISEMPTY", SWIG_From_int((int)(-22)));
+ rb_define_const(mCdiLib, "CDI_EUFTYPE", SWIG_From_int((int)(-23)));
+ rb_define_const(mCdiLib, "CDI_ELIBNAVAIL", SWIG_From_int((int)(-24)));
+ rb_define_const(mCdiLib, "CDI_EUFSTRUCT", SWIG_From_int((int)(-25)));
+ rb_define_const(mCdiLib, "CDI_EUNC4", SWIG_From_int((int)(-26)));
+ rb_define_const(mCdiLib, "CDI_EDIMSIZE", SWIG_From_int((int)(-27)));
+ rb_define_const(mCdiLib, "CDI_ELIMIT", SWIG_From_int((int)(-99)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_GRB", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_GRB2", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_NC", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_NC2", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_NC4", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_NC4C", SWIG_From_int((int)(6)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_NC5", SWIG_From_int((int)(7)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_SRV", SWIG_From_int((int)(8)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_EXT", SWIG_From_int((int)(9)));
+ rb_define_const(mCdiLib, "CDI_FILETYPE_IEG", SWIG_From_int((int)(10)));
+ rb_define_const(mCdiLib, "CDI_COMPRESS_NONE", SWIG_From_int((int)(0)));
+ rb_define_const(mCdiLib, "CDI_COMPRESS_SZIP", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_COMPRESS_AEC", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_COMPRESS_ZIP", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "CDI_COMPRESS_JPEG", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK", SWIG_From_int((int)(0)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK1", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK2", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK3", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK4", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK5", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK6", SWIG_From_int((int)(6)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK7", SWIG_From_int((int)(7)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK8", SWIG_From_int((int)(8)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK9", SWIG_From_int((int)(9)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK10", SWIG_From_int((int)(10)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK11", SWIG_From_int((int)(11)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK12", SWIG_From_int((int)(12)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK13", SWIG_From_int((int)(13)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK14", SWIG_From_int((int)(14)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK15", SWIG_From_int((int)(15)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK16", SWIG_From_int((int)(16)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK17", SWIG_From_int((int)(17)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK18", SWIG_From_int((int)(18)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK19", SWIG_From_int((int)(19)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK20", SWIG_From_int((int)(20)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK21", SWIG_From_int((int)(21)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK22", SWIG_From_int((int)(22)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK23", SWIG_From_int((int)(23)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK24", SWIG_From_int((int)(24)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK25", SWIG_From_int((int)(25)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK26", SWIG_From_int((int)(26)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK27", SWIG_From_int((int)(27)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK28", SWIG_From_int((int)(28)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK29", SWIG_From_int((int)(29)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK30", SWIG_From_int((int)(30)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK31", SWIG_From_int((int)(31)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_PACK32", SWIG_From_int((int)(32)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_CPX32", SWIG_From_int((int)(64)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_CPX64", SWIG_From_int((int)(128)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_FLT32", SWIG_From_int((int)(132)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_FLT64", SWIG_From_int((int)(164)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_INT8", SWIG_From_int((int)(208)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_INT16", SWIG_From_int((int)(216)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_INT32", SWIG_From_int((int)(232)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_UINT8", SWIG_From_int((int)(308)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_UINT16", SWIG_From_int((int)(316)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_UINT32", SWIG_From_int((int)(332)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_INT", SWIG_From_int((int)(251)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_FLT", SWIG_From_int((int)(252)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_TXT", SWIG_From_int((int)(253)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_CPX", SWIG_From_int((int)(254)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_UCHAR", SWIG_From_int((int)(255)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_LONG", SWIG_From_int((int)(256)));
+ rb_define_const(mCdiLib, "CDI_DATATYPE_UINT", SWIG_From_int((int)(257)));
+ rb_define_const(mCdiLib, "CDI_CHUNK_AUTO", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CDI_CHUNK_GRID", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CDI_CHUNK_LINES", SWIG_From_int((int)(3)));
rb_define_const(mCdiLib, "GRID_GENERIC", SWIG_From_int((int)(1)));
rb_define_const(mCdiLib, "GRID_GAUSSIAN", SWIG_From_int((int)(2)));
rb_define_const(mCdiLib, "GRID_GAUSSIAN_REDUCED", SWIG_From_int((int)(3)));
@@ -11861,10 +17834,13 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_const(mCdiLib, "GRID_TRAJECTORY", SWIG_From_int((int)(8)));
rb_define_const(mCdiLib, "GRID_UNSTRUCTURED", SWIG_From_int((int)(9)));
rb_define_const(mCdiLib, "GRID_CURVILINEAR", SWIG_From_int((int)(10)));
- rb_define_const(mCdiLib, "GRID_LCC", SWIG_From_int((int)(11)));
- rb_define_const(mCdiLib, "GRID_LCC2", SWIG_From_int((int)(12)));
- rb_define_const(mCdiLib, "GRID_LAEA", SWIG_From_int((int)(13)));
- rb_define_const(mCdiLib, "GRID_SINUSOIDAL", SWIG_From_int((int)(14)));
+ rb_define_const(mCdiLib, "GRID_PROJECTION", SWIG_From_int((int)(12)));
+ rb_define_const(mCdiLib, "GRID_CHARXY", SWIG_From_int((int)(13)));
+ rb_define_const(mCdiLib, "CDI_PROJ_RLL", SWIG_From_int((int)(21)));
+ rb_define_const(mCdiLib, "CDI_PROJ_LCC", SWIG_From_int((int)(22)));
+ rb_define_const(mCdiLib, "CDI_PROJ_LAEA", SWIG_From_int((int)(23)));
+ rb_define_const(mCdiLib, "CDI_PROJ_SINU", SWIG_From_int((int)(24)));
+ rb_define_const(mCdiLib, "CDI_PROJ_STERE", SWIG_From_int((int)(25)));
rb_define_const(mCdiLib, "ZAXIS_SURFACE", SWIG_From_int((int)(0)));
rb_define_const(mCdiLib, "ZAXIS_GENERIC", SWIG_From_int((int)(1)));
rb_define_const(mCdiLib, "ZAXIS_HYBRID", SWIG_From_int((int)(2)));
@@ -11878,60 +17854,190 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_const(mCdiLib, "ZAXIS_ALTITUDE", SWIG_From_int((int)(10)));
rb_define_const(mCdiLib, "ZAXIS_SIGMA", SWIG_From_int((int)(11)));
rb_define_const(mCdiLib, "ZAXIS_MEANSEA", SWIG_From_int((int)(12)));
+ rb_define_const(mCdiLib, "ZAXIS_TOA", SWIG_From_int((int)(13)));
+ rb_define_const(mCdiLib, "ZAXIS_SEA_BOTTOM", SWIG_From_int((int)(14)));
+ rb_define_const(mCdiLib, "ZAXIS_ATMOSPHERE", SWIG_From_int((int)(15)));
+ rb_define_const(mCdiLib, "ZAXIS_CLOUD_BASE", SWIG_From_int((int)(16)));
+ rb_define_const(mCdiLib, "ZAXIS_CLOUD_TOP", SWIG_From_int((int)(17)));
+ rb_define_const(mCdiLib, "ZAXIS_ISOTHERM_ZERO", SWIG_From_int((int)(18)));
+ rb_define_const(mCdiLib, "ZAXIS_SNOW", SWIG_From_int((int)(19)));
+ rb_define_const(mCdiLib, "ZAXIS_LAKE_BOTTOM", SWIG_From_int((int)(20)));
+ rb_define_const(mCdiLib, "ZAXIS_SEDIMENT_BOTTOM", SWIG_From_int((int)(21)));
+ rb_define_const(mCdiLib, "ZAXIS_SEDIMENT_BOTTOM_TA", SWIG_From_int((int)(22)));
+ rb_define_const(mCdiLib, "ZAXIS_SEDIMENT_BOTTOM_TW", SWIG_From_int((int)(23)));
+ rb_define_const(mCdiLib, "ZAXIS_MIX_LAYER", SWIG_From_int((int)(24)));
+ rb_define_const(mCdiLib, "ZAXIS_REFERENCE", SWIG_From_int((int)(25)));
+ rb_define_const(mCdiLib, "ZAXIS_CHAR", SWIG_From_int((int)(26)));
+ rb_define_const(mCdiLib, "SUBTYPE_TILES", SWIG_From_int((int)(SUBTYPE_TILES)));
+ rb_define_const(mCdiLib, "MAX_KV_PAIRS_MATCH", SWIG_From_int((int)(10)));
+
+ SwigClassSubtype_query_t.klass = rb_define_class_under(mCdiLib, "Subtype_query_t", rb_cObject);
+ SWIG_TypeClientData(SWIGTYPE_p_subtype_query_t, (void *) &SwigClassSubtype_query_t);
+ rb_define_alloc_func(SwigClassSubtype_query_t.klass, _wrap_subtype_query_t_allocate);
+ rb_define_method(SwigClassSubtype_query_t.klass, "initialize", _wrap_new_subtype_query_t, -1);
+ rb_define_method(SwigClassSubtype_query_t.klass, "nAND=", _wrap_subtype_query_t_nAND_set, -1);
+ rb_define_method(SwigClassSubtype_query_t.klass, "nAND", _wrap_subtype_query_t_nAND_get, -1);
+ rb_define_method(SwigClassSubtype_query_t.klass, "key_value_pairs=", _wrap_subtype_query_t_key_value_pairs_set, -1);
+ rb_define_method(SwigClassSubtype_query_t.klass, "key_value_pairs", _wrap_subtype_query_t_key_value_pairs_get, -1);
+ SwigClassSubtype_query_t.mark = 0;
+ SwigClassSubtype_query_t.destroy = (void (*)(void *)) free_subtype_query_t;
+ SwigClassSubtype_query_t.trackObjects = 0;
+ rb_define_const(mCdiLib, "TIME_CONSTANT", SWIG_From_int((int)(0)));
+ rb_define_const(mCdiLib, "TIME_VARYING", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "TIME_VARIABLE", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "TSTEP_INSTANT", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "TSTEP_AVG", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "TSTEP_ACCUM", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "TSTEP_MAX", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "TSTEP_MIN", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "TSTEP_DIFF", SWIG_From_int((int)(6)));
+ rb_define_const(mCdiLib, "TSTEP_RMS", SWIG_From_int((int)(7)));
+ rb_define_const(mCdiLib, "TSTEP_SD", SWIG_From_int((int)(8)));
+ rb_define_const(mCdiLib, "TSTEP_COV", SWIG_From_int((int)(9)));
+ rb_define_const(mCdiLib, "TSTEP_RATIO", SWIG_From_int((int)(10)));
+ rb_define_const(mCdiLib, "TSTEP_SUM", SWIG_From_int((int)(11)));
+ rb_define_const(mCdiLib, "TSTEP_RANGE", SWIG_From_int((int)(12)));
+ rb_define_const(mCdiLib, "TSTEP_INSTANT2", SWIG_From_int((int)(13)));
+ rb_define_const(mCdiLib, "TSTEP_INSTANT3", SWIG_From_int((int)(14)));
rb_define_const(mCdiLib, "TAXIS_ABSOLUTE", SWIG_From_int((int)(1)));
rb_define_const(mCdiLib, "TAXIS_RELATIVE", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "TIME_CONSTANT", SWIG_From_int((int)(1)));
- rb_define_const(mCdiLib, "TIME_VARIABLE", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "TAXIS_FORECAST", SWIG_From_int((int)(3)));
rb_define_const(mCdiLib, "TUNIT_SECOND", SWIG_From_int((int)(1)));
rb_define_const(mCdiLib, "TUNIT_MINUTE", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "TUNIT_HOUR", SWIG_From_int((int)(3)));
- rb_define_const(mCdiLib, "TUNIT_DAY", SWIG_From_int((int)(4)));
- rb_define_const(mCdiLib, "TUNIT_MONTH", SWIG_From_int((int)(5)));
- rb_define_const(mCdiLib, "TUNIT_YEAR", SWIG_From_int((int)(6)));
- rb_define_const(mCdiLib, "TUNIT_QUARTER", SWIG_From_int((int)(7)));
+ rb_define_const(mCdiLib, "TUNIT_QUARTER", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "TUNIT_30MINUTES", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "TUNIT_HOUR", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "TUNIT_3HOURS", SWIG_From_int((int)(6)));
+ rb_define_const(mCdiLib, "TUNIT_6HOURS", SWIG_From_int((int)(7)));
+ rb_define_const(mCdiLib, "TUNIT_12HOURS", SWIG_From_int((int)(8)));
+ rb_define_const(mCdiLib, "TUNIT_DAY", SWIG_From_int((int)(9)));
+ rb_define_const(mCdiLib, "TUNIT_MONTH", SWIG_From_int((int)(10)));
+ rb_define_const(mCdiLib, "TUNIT_YEAR", SWIG_From_int((int)(11)));
rb_define_const(mCdiLib, "CALENDAR_STANDARD", SWIG_From_int((int)(0)));
- rb_define_const(mCdiLib, "CALENDAR_PROLEPTIC", SWIG_From_int((int)(1)));
- rb_define_const(mCdiLib, "CALENDAR_360DAYS", SWIG_From_int((int)(2)));
- rb_define_const(mCdiLib, "CALENDAR_365DAYS", SWIG_From_int((int)(3)));
- rb_define_const(mCdiLib, "CALENDAR_366DAYS", SWIG_From_int((int)(4)));
- rb_define_const(mCdiLib, "CALENDAR_NONE", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "CALENDAR_GREGORIAN", SWIG_From_int((int)(1)));
+ rb_define_const(mCdiLib, "CALENDAR_PROLEPTIC", SWIG_From_int((int)(2)));
+ rb_define_const(mCdiLib, "CALENDAR_360DAYS", SWIG_From_int((int)(3)));
+ rb_define_const(mCdiLib, "CALENDAR_365DAYS", SWIG_From_int((int)(4)));
+ rb_define_const(mCdiLib, "CALENDAR_366DAYS", SWIG_From_int((int)(5)));
+ rb_define_const(mCdiLib, "CALENDAR_NONE", SWIG_From_int((int)(6)));
+ rb_define_const(mCdiLib, "CDI_UUID_SIZE", SWIG_From_int((int)(16)));
+
+ SwigClassCdiParam.klass = rb_define_class_under(mCdiLib, "CdiParam", rb_cObject);
+ SWIG_TypeClientData(SWIGTYPE_p_CdiParam, (void *) &SwigClassCdiParam);
+ rb_define_alloc_func(SwigClassCdiParam.klass, _wrap_CdiParam_allocate);
+ rb_define_method(SwigClassCdiParam.klass, "initialize", _wrap_new_CdiParam, -1);
+ rb_define_method(SwigClassCdiParam.klass, "discipline=", _wrap_CdiParam_discipline_set, -1);
+ rb_define_method(SwigClassCdiParam.klass, "discipline", _wrap_CdiParam_discipline_get, -1);
+ rb_define_method(SwigClassCdiParam.klass, "category=", _wrap_CdiParam_category_set, -1);
+ rb_define_method(SwigClassCdiParam.klass, "category", _wrap_CdiParam_category_get, -1);
+ rb_define_method(SwigClassCdiParam.klass, "number=", _wrap_CdiParam_number_set, -1);
+ rb_define_method(SwigClassCdiParam.klass, "number", _wrap_CdiParam_number_get, -1);
+ SwigClassCdiParam.mark = 0;
+ SwigClassCdiParam.destroy = (void (*)(void *)) free_CdiParam;
+ SwigClassCdiParam.trackObjects = 0;
+ rb_define_module_function(mCdiLib, "cdiReset", _wrap_cdiReset, -1);
rb_define_module_function(mCdiLib, "cdiStringError", _wrap_cdiStringError, -1);
rb_define_module_function(mCdiLib, "cdiDebug", _wrap_cdiDebug, -1);
rb_define_module_function(mCdiLib, "cdiLibraryVersion", _wrap_cdiLibraryVersion, -1);
rb_define_module_function(mCdiLib, "cdiPrintVersion", _wrap_cdiPrintVersion, -1);
+ rb_define_module_function(mCdiLib, "cdiHaveFiletype", _wrap_cdiHaveFiletype, -1);
rb_define_module_function(mCdiLib, "cdiDefMissval", _wrap_cdiDefMissval, -1);
rb_define_module_function(mCdiLib, "cdiInqMissval", _wrap_cdiInqMissval, -1);
+ rb_define_module_function(mCdiLib, "cdiInqGridMissval", _wrap_cdiInqGridMissval, -1);
rb_define_module_function(mCdiLib, "cdiDefGlobal", _wrap_cdiDefGlobal, -1);
+ rb_define_module_function(mCdiLib, "namespaceNew", _wrap_namespaceNew, -1);
+ rb_define_module_function(mCdiLib, "namespaceSetActive", _wrap_namespaceSetActive, -1);
+ rb_define_module_function(mCdiLib, "namespaceGetActive", _wrap_namespaceGetActive, -1);
+ rb_define_module_function(mCdiLib, "namespaceDelete", _wrap_namespaceDelete, -1);
+ rb_define_module_function(mCdiLib, "cdiParamToString", _wrap_cdiParamToString, -1);
+ rb_define_module_function(mCdiLib, "cdiDecodeParam", _wrap_cdiDecodeParam, -1);
+ rb_define_module_function(mCdiLib, "cdiEncodeParam", _wrap_cdiEncodeParam, -1);
+ rb_define_module_function(mCdiLib, "cdiDecodeDate", _wrap_cdiDecodeDate, -1);
+ rb_define_module_function(mCdiLib, "cdiEncodeDate", _wrap_cdiEncodeDate, -1);
+ rb_define_module_function(mCdiLib, "cdiDecodeTime", _wrap_cdiDecodeTime, -1);
+ rb_define_module_function(mCdiLib, "cdiEncodeTime", _wrap_cdiEncodeTime, -1);
+ rb_define_module_function(mCdiLib, "cdiGetFiletype", _wrap_cdiGetFiletype, -1);
rb_define_module_function(mCdiLib, "streamOpenRead", _wrap_streamOpenRead, -1);
rb_define_module_function(mCdiLib, "streamOpenWrite", _wrap_streamOpenWrite, -1);
rb_define_module_function(mCdiLib, "streamOpenAppend", _wrap_streamOpenAppend, -1);
rb_define_module_function(mCdiLib, "streamClose", _wrap_streamClose, -1);
rb_define_module_function(mCdiLib, "streamSync", _wrap_streamSync, -1);
+ rb_define_module_function(mCdiLib, "streamDefNumWorker", _wrap_streamDefNumWorker, -1);
rb_define_module_function(mCdiLib, "streamDefVlist", _wrap_streamDefVlist, -1);
rb_define_module_function(mCdiLib, "streamInqVlist", _wrap_streamInqVlist, -1);
rb_define_module_function(mCdiLib, "streamInqFiletype", _wrap_streamInqFiletype, -1);
rb_define_module_function(mCdiLib, "streamDefByteorder", _wrap_streamDefByteorder, -1);
rb_define_module_function(mCdiLib, "streamInqByteorder", _wrap_streamInqByteorder, -1);
- rb_define_module_function(mCdiLib, "streamDefZtype", _wrap_streamDefZtype, -1);
- rb_define_module_function(mCdiLib, "streamDefZlevel", _wrap_streamDefZlevel, -1);
- rb_define_module_function(mCdiLib, "streamInqZtype", _wrap_streamInqZtype, -1);
- rb_define_module_function(mCdiLib, "streamInqZlevel", _wrap_streamInqZlevel, -1);
+ rb_define_module_function(mCdiLib, "streamDefCompType", _wrap_streamDefCompType, -1);
+ rb_define_module_function(mCdiLib, "streamInqCompType", _wrap_streamInqCompType, -1);
+ rb_define_module_function(mCdiLib, "streamDefCompLevel", _wrap_streamDefCompLevel, -1);
+ rb_define_module_function(mCdiLib, "streamInqCompLevel", _wrap_streamInqCompLevel, -1);
rb_define_module_function(mCdiLib, "streamDefTimestep", _wrap_streamDefTimestep, -1);
rb_define_module_function(mCdiLib, "streamInqTimestep", _wrap_streamInqTimestep, -1);
+ rb_define_module_function(mCdiLib, "streamInqCurTimestepID", _wrap_streamInqCurTimestepID, -1);
rb_define_module_function(mCdiLib, "streamFilename", _wrap_streamFilename, -1);
rb_define_module_function(mCdiLib, "streamFilesuffix", _wrap_streamFilesuffix, -1);
- rb_define_module_function(mCdiLib, "streamNtsteps", _wrap_streamNtsteps, -1);
rb_define_module_function(mCdiLib, "streamNvals", _wrap_streamNvals, -1);
- rb_define_module_function(mCdiLib, "streamReadVar", _wrap_streamReadVar, -1);
+ rb_define_module_function(mCdiLib, "streamInqNvars", _wrap_streamInqNvars, -1);
rb_define_module_function(mCdiLib, "streamWriteVar", _wrap_streamWriteVar, -1);
- rb_define_module_function(mCdiLib, "streamReadVarSlice", _wrap_streamReadVarSlice, -1);
+ rb_define_module_function(mCdiLib, "streamWriteVarF", _wrap_streamWriteVarF, -1);
+ rb_define_module_function(mCdiLib, "streamReadVar", _wrap_streamReadVar, -1);
+ rb_define_module_function(mCdiLib, "streamReadVarF", _wrap_streamReadVarF, -1);
+ rb_define_module_function(mCdiLib, "streamReadVarPart", _wrap_streamReadVarPart, -1);
rb_define_module_function(mCdiLib, "streamWriteVarSlice", _wrap_streamWriteVarSlice, -1);
- rb_define_module_function(mCdiLib, "streamInqRecord", _wrap_streamInqRecord, -1);
+ rb_define_module_function(mCdiLib, "streamWriteVarSliceF", _wrap_streamWriteVarSliceF, -1);
+ rb_define_module_function(mCdiLib, "streamReadVarSlicePart", _wrap_streamReadVarSlicePart, -1);
+ rb_define_module_function(mCdiLib, "streamReadVarSlice", _wrap_streamReadVarSlice, -1);
+ rb_define_module_function(mCdiLib, "streamReadVarSliceF", _wrap_streamReadVarSliceF, -1);
+ rb_define_module_function(mCdiLib, "streamWriteVarChunk", _wrap_streamWriteVarChunk, -1);
rb_define_module_function(mCdiLib, "streamDefRecord", _wrap_streamDefRecord, -1);
- rb_define_module_function(mCdiLib, "streamReadRecord", _wrap_streamReadRecord, -1);
+ rb_define_module_function(mCdiLib, "streamInqRecord", _wrap_streamInqRecord, -1);
rb_define_module_function(mCdiLib, "streamWriteRecord", _wrap_streamWriteRecord, -1);
+ rb_define_module_function(mCdiLib, "streamWriteRecordF", _wrap_streamWriteRecordF, -1);
+ rb_define_module_function(mCdiLib, "streamReadRecord", _wrap_streamReadRecord, -1);
+ rb_define_module_function(mCdiLib, "streamReadRecordF", _wrap_streamReadRecordF, -1);
rb_define_module_function(mCdiLib, "streamCopyRecord", _wrap_streamCopyRecord, -1);
- rb_define_module_function(mCdiLib, "streamInqGinfo", _wrap_streamInqGinfo, -1);
+ rb_define_module_function(mCdiLib, "streamInqGRIBinfo", _wrap_streamInqGRIBinfo, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_new", _wrap_cdiIterator_new, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_clone", _wrap_cdiIterator_clone, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_serialize", _wrap_cdiIterator_serialize, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_deserialize", _wrap_cdiIterator_deserialize, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_print", _wrap_cdiIterator_print, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_delete", _wrap_cdiIterator_delete, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_nextField", _wrap_cdiIterator_nextField, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqStartTime", _wrap_cdiIterator_inqStartTime, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqEndTime", _wrap_cdiIterator_inqEndTime, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqRTime", _wrap_cdiIterator_inqRTime, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqVTime", _wrap_cdiIterator_inqVTime, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqLevelType", _wrap_cdiIterator_inqLevelType, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqLevel", _wrap_cdiIterator_inqLevel, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqLevelUuid", _wrap_cdiIterator_inqLevelUuid, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqTile", _wrap_cdiIterator_inqTile, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqTileCount", _wrap_cdiIterator_inqTileCount, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqParam", _wrap_cdiIterator_inqParam, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqParamParts", _wrap_cdiIterator_inqParamParts, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqDatatype", _wrap_cdiIterator_inqDatatype, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqFiletype", _wrap_cdiIterator_inqFiletype, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqTsteptype", _wrap_cdiIterator_inqTsteptype, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqVariableName", _wrap_cdiIterator_inqVariableName, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_inqGridId", _wrap_cdiIterator_inqGridId, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_readField", _wrap_cdiIterator_readField, -1);
+ rb_define_module_function(mCdiLib, "cdiIterator_readFieldF", _wrap_cdiIterator_readFieldF, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_clone", _wrap_cdiGribIterator_clone, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_delete", _wrap_cdiGribIterator_delete, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getLong", _wrap_cdiGribIterator_getLong, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getDouble", _wrap_cdiGribIterator_getDouble, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getLength", _wrap_cdiGribIterator_getLength, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getString", _wrap_cdiGribIterator_getString, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getSize", _wrap_cdiGribIterator_getSize, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getLongArray", _wrap_cdiGribIterator_getLongArray, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_getDoubleArray", _wrap_cdiGribIterator_getDoubleArray, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqEdition", _wrap_cdiGribIterator_inqEdition, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqLongValue", _wrap_cdiGribIterator_inqLongValue, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqLongDefaultValue", _wrap_cdiGribIterator_inqLongDefaultValue, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqDoubleValue", _wrap_cdiGribIterator_inqDoubleValue, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqDoubleDefaultValue", _wrap_cdiGribIterator_inqDoubleDefaultValue, -1);
+ rb_define_module_function(mCdiLib, "cdiGribIterator_inqStringValue", _wrap_cdiGribIterator_inqStringValue, -1);
rb_define_module_function(mCdiLib, "vlistCreate", _wrap_vlistCreate, -1);
rb_define_module_function(mCdiLib, "vlistDestroy", _wrap_vlistDestroy, -1);
rb_define_module_function(mCdiLib, "vlistDuplicate", _wrap_vlistDuplicate, -1);
@@ -11941,9 +18047,11 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "vlistCat", _wrap_vlistCat, -1);
rb_define_module_function(mCdiLib, "vlistMerge", _wrap_vlistMerge, -1);
rb_define_module_function(mCdiLib, "vlistPrint", _wrap_vlistPrint, -1);
+ rb_define_module_function(mCdiLib, "vlistNumber", _wrap_vlistNumber, -1);
rb_define_module_function(mCdiLib, "vlistNvars", _wrap_vlistNvars, -1);
rb_define_module_function(mCdiLib, "vlistNgrids", _wrap_vlistNgrids, -1);
rb_define_module_function(mCdiLib, "vlistNzaxis", _wrap_vlistNzaxis, -1);
+ rb_define_module_function(mCdiLib, "vlistNsubtypes", _wrap_vlistNsubtypes, -1);
rb_define_module_function(mCdiLib, "vlistDefNtsteps", _wrap_vlistDefNtsteps, -1);
rb_define_module_function(mCdiLib, "vlistNtsteps", _wrap_vlistNtsteps, -1);
rb_define_module_function(mCdiLib, "vlistGridsizeMax", _wrap_vlistGridsizeMax, -1);
@@ -11956,6 +18064,8 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "vlistChangeZaxisIndex", _wrap_vlistChangeZaxisIndex, -1);
rb_define_module_function(mCdiLib, "vlistChangeZaxis", _wrap_vlistChangeZaxis, -1);
rb_define_module_function(mCdiLib, "vlistNrecs", _wrap_vlistNrecs, -1);
+ rb_define_module_function(mCdiLib, "vlistSubtype", _wrap_vlistSubtype, -1);
+ rb_define_module_function(mCdiLib, "vlistSubtypeIndex", _wrap_vlistSubtypeIndex, -1);
rb_define_module_function(mCdiLib, "vlistDefTaxis", _wrap_vlistDefTaxis, -1);
rb_define_module_function(mCdiLib, "vlistInqTaxis", _wrap_vlistInqTaxis, -1);
rb_define_module_function(mCdiLib, "vlistDefTable", _wrap_vlistDefTable, -1);
@@ -11964,21 +18074,33 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "vlistInqInstitut", _wrap_vlistInqInstitut, -1);
rb_define_module_function(mCdiLib, "vlistDefModel", _wrap_vlistDefModel, -1);
rb_define_module_function(mCdiLib, "vlistInqModel", _wrap_vlistInqModel, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarTiles", _wrap_vlistDefVarTiles, -1);
rb_define_module_function(mCdiLib, "vlistDefVar", _wrap_vlistDefVar, -1);
rb_define_module_function(mCdiLib, "vlistChangeVarGrid", _wrap_vlistChangeVarGrid, -1);
rb_define_module_function(mCdiLib, "vlistChangeVarZaxis", _wrap_vlistChangeVarZaxis, -1);
rb_define_module_function(mCdiLib, "vlistInqVar", _wrap_vlistInqVar, -1);
rb_define_module_function(mCdiLib, "vlistInqVarGrid", _wrap_vlistInqVarGrid, -1);
rb_define_module_function(mCdiLib, "vlistInqVarZaxis", _wrap_vlistInqVarZaxis, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarTime", _wrap_vlistInqVarTime, -1);
- rb_define_module_function(mCdiLib, "vlistDefVarZtype", _wrap_vlistDefVarZtype, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarZtype", _wrap_vlistInqVarZtype, -1);
- rb_define_module_function(mCdiLib, "vlistDefVarZlevel", _wrap_vlistDefVarZlevel, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarZlevel", _wrap_vlistInqVarZlevel, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarID", _wrap_vlistInqVarID, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarTimetype", _wrap_vlistDefVarTimetype, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarTimetype", _wrap_vlistInqVarTimetype, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarTsteptype", _wrap_vlistDefVarTsteptype, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarTsteptype", _wrap_vlistInqVarTsteptype, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarCompType", _wrap_vlistDefVarCompType, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarCompType", _wrap_vlistInqVarCompType, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarCompLevel", _wrap_vlistDefVarCompLevel, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarCompLevel", _wrap_vlistInqVarCompLevel, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarParam", _wrap_vlistDefVarParam, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarParam", _wrap_vlistInqVarParam, -1);
rb_define_module_function(mCdiLib, "vlistDefVarCode", _wrap_vlistDefVarCode, -1);
rb_define_module_function(mCdiLib, "vlistInqVarCode", _wrap_vlistInqVarCode, -1);
rb_define_module_function(mCdiLib, "vlistDefVarDatatype", _wrap_vlistDefVarDatatype, -1);
rb_define_module_function(mCdiLib, "vlistInqVarDatatype", _wrap_vlistInqVarDatatype, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarChunkType", _wrap_vlistDefVarChunkType, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarChunkType", _wrap_vlistInqVarChunkType, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarXYZ", _wrap_vlistDefVarXYZ, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarXYZ", _wrap_vlistInqVarXYZ, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarNumber", _wrap_vlistInqVarNumber, -1);
rb_define_module_function(mCdiLib, "vlistDefVarInstitut", _wrap_vlistDefVarInstitut, -1);
rb_define_module_function(mCdiLib, "vlistInqVarInstitut", _wrap_vlistInqVarInstitut, -1);
rb_define_module_function(mCdiLib, "vlistDefVarModel", _wrap_vlistDefVarModel, -1);
@@ -11987,24 +18109,24 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "vlistInqVarTable", _wrap_vlistInqVarTable, -1);
rb_define_module_function(mCdiLib, "vlistDefVarName", _wrap_vlistDefVarName, -1);
rb_define_module_function(mCdiLib, "vlistInqVarName", _wrap_vlistInqVarName, -1);
- rb_define_module_function(mCdiLib, "vlistDefVarLongname", _wrap_vlistDefVarLongname, -1);
+ rb_define_module_function(mCdiLib, "vlistCopyVarName", _wrap_vlistCopyVarName, -1);
rb_define_module_function(mCdiLib, "vlistDefVarStdname", _wrap_vlistDefVarStdname, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarLongname", _wrap_vlistInqVarLongname, -1);
rb_define_module_function(mCdiLib, "vlistInqVarStdname", _wrap_vlistInqVarStdname, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarLongname", _wrap_vlistDefVarLongname, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarLongname", _wrap_vlistInqVarLongname, -1);
rb_define_module_function(mCdiLib, "vlistDefVarUnits", _wrap_vlistDefVarUnits, -1);
rb_define_module_function(mCdiLib, "vlistInqVarUnits", _wrap_vlistInqVarUnits, -1);
rb_define_module_function(mCdiLib, "vlistDefVarMissval", _wrap_vlistDefVarMissval, -1);
rb_define_module_function(mCdiLib, "vlistInqVarMissval", _wrap_vlistInqVarMissval, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarExtra", _wrap_vlistDefVarExtra, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarExtra", _wrap_vlistInqVarExtra, -1);
rb_define_module_function(mCdiLib, "vlistDefVarScalefactor", _wrap_vlistDefVarScalefactor, -1);
rb_define_module_function(mCdiLib, "vlistInqVarScalefactor", _wrap_vlistInqVarScalefactor, -1);
rb_define_module_function(mCdiLib, "vlistDefVarAddoffset", _wrap_vlistDefVarAddoffset, -1);
rb_define_module_function(mCdiLib, "vlistInqVarAddoffset", _wrap_vlistInqVarAddoffset, -1);
rb_define_module_function(mCdiLib, "vlistDefVarTimave", _wrap_vlistDefVarTimave, -1);
rb_define_module_function(mCdiLib, "vlistInqVarTimave", _wrap_vlistInqVarTimave, -1);
- rb_define_module_function(mCdiLib, "vlistDefVarTimaccu", _wrap_vlistDefVarTimaccu, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarTimaccu", _wrap_vlistInqVarTimaccu, -1);
rb_define_module_function(mCdiLib, "vlistInqVarSize", _wrap_vlistInqVarSize, -1);
- rb_define_module_function(mCdiLib, "vlistInqVarID", _wrap_vlistInqVarID, -1);
rb_define_module_function(mCdiLib, "vlistDefIndex", _wrap_vlistDefIndex, -1);
rb_define_module_function(mCdiLib, "vlistInqIndex", _wrap_vlistInqIndex, -1);
rb_define_module_function(mCdiLib, "vlistDefFlag", _wrap_vlistDefFlag, -1);
@@ -12013,49 +18135,122 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "vlistFindLevel", _wrap_vlistFindLevel, -1);
rb_define_module_function(mCdiLib, "vlistMergedVar", _wrap_vlistMergedVar, -1);
rb_define_module_function(mCdiLib, "vlistMergedLevel", _wrap_vlistMergedLevel, -1);
- rb_define_module_function(mCdiLib, "vlistInqNatts", _wrap_vlistInqNatts, -1);
- rb_define_module_function(mCdiLib, "vlistInqAtt", _wrap_vlistInqAtt, -1);
- rb_define_module_function(mCdiLib, "vlistDelAtt", _wrap_vlistDelAtt, -1);
- rb_define_module_function(mCdiLib, "vlistDefAttInt", _wrap_vlistDefAttInt, -1);
- rb_define_module_function(mCdiLib, "vlistDefAttFlt", _wrap_vlistDefAttFlt, -1);
- rb_define_module_function(mCdiLib, "vlistDefAttTxt", _wrap_vlistDefAttTxt, -1);
- rb_define_module_function(mCdiLib, "vlistInqAttInt", _wrap_vlistInqAttInt, -1);
- rb_define_module_function(mCdiLib, "vlistInqAttFlt", _wrap_vlistInqAttFlt, -1);
- rb_define_module_function(mCdiLib, "vlistInqAttTxt", _wrap_vlistInqAttTxt, -1);
+ rb_define_module_function(mCdiLib, "cdiClearAdditionalKeys", _wrap_cdiClearAdditionalKeys, -1);
+ rb_define_module_function(mCdiLib, "cdiDefAdditionalKey", _wrap_cdiDefAdditionalKey, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarIntKey", _wrap_vlistDefVarIntKey, -1);
+ rb_define_module_function(mCdiLib, "vlistDefVarDblKey", _wrap_vlistDefVarDblKey, -1);
+ rb_define_module_function(mCdiLib, "vlistHasVarKey", _wrap_vlistHasVarKey, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarDblKey", _wrap_vlistInqVarDblKey, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarIntKey", _wrap_vlistInqVarIntKey, -1);
+ rb_define_module_function(mCdiLib, "cdiInqNatts", _wrap_cdiInqNatts, -1);
+ rb_define_module_function(mCdiLib, "cdiInqAtt", _wrap_cdiInqAtt, -1);
+ rb_define_module_function(mCdiLib, "cdiDelAtt", _wrap_cdiDelAtt, -1);
+ rb_define_module_function(mCdiLib, "cdiCopyAtts", _wrap_cdiCopyAtts, -1);
+ rb_define_module_function(mCdiLib, "cdiDefAttInt", _wrap_cdiDefAttInt, -1);
+ rb_define_module_function(mCdiLib, "cdiDefAttFlt", _wrap_cdiDefAttFlt, -1);
+ rb_define_module_function(mCdiLib, "cdiDefAttTxt", _wrap_cdiDefAttTxt, -1);
+ rb_define_module_function(mCdiLib, "cdiInqAttInt", _wrap_cdiInqAttInt, -1);
+ rb_define_module_function(mCdiLib, "cdiInqAttFlt", _wrap_cdiInqAttFlt, -1);
+ rb_define_module_function(mCdiLib, "cdiInqAttTxt", _wrap_cdiInqAttTxt, -1);
rb_define_module_function(mCdiLib, "gridName", _wrap_gridName, -1);
rb_define_module_function(mCdiLib, "gridNamePtr", _wrap_gridNamePtr, -1);
rb_define_module_function(mCdiLib, "gridCompress", _wrap_gridCompress, -1);
+ rb_define_module_function(mCdiLib, "gridDefMaskGME", _wrap_gridDefMaskGME, -1);
+ rb_define_module_function(mCdiLib, "gridInqMaskGME", _wrap_gridInqMaskGME, -1);
rb_define_module_function(mCdiLib, "gridDefMask", _wrap_gridDefMask, -1);
rb_define_module_function(mCdiLib, "gridInqMask", _wrap_gridInqMask, -1);
- rb_define_module_function(mCdiLib, "gridPrint", _wrap_gridPrint, -1);
- rb_define_module_function(mCdiLib, "gridSize", _wrap_gridSize, -1);
rb_define_module_function(mCdiLib, "gridCreate", _wrap_gridCreate, -1);
rb_define_module_function(mCdiLib, "gridDestroy", _wrap_gridDestroy, -1);
rb_define_module_function(mCdiLib, "gridDuplicate", _wrap_gridDuplicate, -1);
+ rb_define_module_function(mCdiLib, "gridDefProj", _wrap_gridDefProj, -1);
+ rb_define_module_function(mCdiLib, "gridInqProj", _wrap_gridInqProj, -1);
+ rb_define_module_function(mCdiLib, "gridInqProjType", _wrap_gridInqProjType, -1);
rb_define_module_function(mCdiLib, "gridInqType", _wrap_gridInqType, -1);
rb_define_module_function(mCdiLib, "gridInqSize", _wrap_gridInqSize, -1);
rb_define_module_function(mCdiLib, "gridDefXsize", _wrap_gridDefXsize, -1);
rb_define_module_function(mCdiLib, "gridInqXsize", _wrap_gridInqXsize, -1);
rb_define_module_function(mCdiLib, "gridDefYsize", _wrap_gridDefYsize, -1);
rb_define_module_function(mCdiLib, "gridInqYsize", _wrap_gridInqYsize, -1);
+ rb_define_module_function(mCdiLib, "gridDefNP", _wrap_gridDefNP, -1);
+ rb_define_module_function(mCdiLib, "gridInqNP", _wrap_gridInqNP, -1);
rb_define_module_function(mCdiLib, "gridDefXvals", _wrap_gridDefXvals, -1);
rb_define_module_function(mCdiLib, "gridInqXvals", _wrap_gridInqXvals, -1);
+ rb_define_module_function(mCdiLib, "gridInqXvalsPart", _wrap_gridInqXvalsPart, -1);
+ rb_define_module_function(mCdiLib, "gridInqXIsc", _wrap_gridInqXIsc, -1);
+ rb_define_module_function(mCdiLib, "gridInqXCvals", _wrap_gridInqXCvals, -1);
rb_define_module_function(mCdiLib, "gridDefYvals", _wrap_gridDefYvals, -1);
rb_define_module_function(mCdiLib, "gridInqYvals", _wrap_gridInqYvals, -1);
+ rb_define_module_function(mCdiLib, "gridInqYvalsPart", _wrap_gridInqYvalsPart, -1);
+ rb_define_module_function(mCdiLib, "gridInqYIsc", _wrap_gridInqYIsc, -1);
+ rb_define_module_function(mCdiLib, "gridInqYCvals", _wrap_gridInqYCvals, -1);
+ rb_define_const(mCdiLib, "CDI_KEY_TABLESVERSION", SWIG_From_int((int)(801)));
+ rb_define_const(mCdiLib, "CDI_KEY_LOCALTABLESVERSION", SWIG_From_int((int)(802)));
+ rb_define_const(mCdiLib, "CDI_KEY_TYPEOFGENERATINGPROCESS", SWIG_From_int((int)(803)));
+ rb_define_const(mCdiLib, "CDI_KEY_PRODUCTDEFINITIONTEMPLATE", SWIG_From_int((int)(804)));
+ rb_define_const(mCdiLib, "CDI_KEY_TYPEOFPROCESSEDDATA", SWIG_From_int((int)(805)));
+ rb_define_const(mCdiLib, "CDI_KEY_SHAPEOFTHEEARTH", SWIG_From_int((int)(806)));
+ rb_define_const(mCdiLib, "CDI_KEY_BACKGROUNDPROCESS", SWIG_From_int((int)(807)));
+ rb_define_const(mCdiLib, "CDI_KEY_TYPEOFENSEMBLEFORECAST", SWIG_From_int((int)(808)));
+ rb_define_const(mCdiLib, "CDI_KEY_NUMBEROFFORECASTSINENSEMBLE", SWIG_From_int((int)(809)));
+ rb_define_const(mCdiLib, "CDI_KEY_PERTURBATIONNUMBER", SWIG_From_int((int)(810)));
+ rb_define_const(mCdiLib, "CDI_KEY_CENTRE", SWIG_From_int((int)(811)));
+ rb_define_const(mCdiLib, "CDI_KEY_SUBCENTRE", SWIG_From_int((int)(812)));
+ rb_define_const(mCdiLib, "CDI_KEY_MPIMTYPE", SWIG_From_int((int)(813)));
+ rb_define_const(mCdiLib, "CDI_KEY_MPIMCLASS", SWIG_From_int((int)(814)));
+ rb_define_const(mCdiLib, "CDI_KEY_MPIMUSER", SWIG_From_int((int)(815)));
+ rb_define_const(mCdiLib, "CDI_KEY_REVSTATUS", SWIG_From_int((int)(816)));
+ rb_define_const(mCdiLib, "CDI_KEY_REVNUMBER", SWIG_From_int((int)(817)));
+ rb_define_const(mCdiLib, "CDI_KEY_GRIB2LOCALSECTIONNUMBER", SWIG_From_int((int)(818)));
+ rb_define_const(mCdiLib, "CDI_KEY_SECTION2PADDINGLENGTH", SWIG_From_int((int)(819)));
+ rb_define_const(mCdiLib, "CDI_KEY_SECTION2PADDING", SWIG_From_int((int)(820)));
+ rb_define_const(mCdiLib, "CDI_KEY_UVRELATIVETOGRID", SWIG_From_int((int)(821)));
+ rb_define_const(mCdiLib, "CDI_KEY_CONSTITUENTTYPE", SWIG_From_int((int)(822)));
+ rb_define_module_function(mCdiLib, "cdiDefKeyInt", _wrap_cdiDefKeyInt, -1);
+ rb_define_module_function(mCdiLib, "cdiInqKeyInt", _wrap_cdiInqKeyInt, -1);
+ rb_define_module_function(mCdiLib, "cdiDefKeyBytes", _wrap_cdiDefKeyBytes, -1);
+ rb_define_module_function(mCdiLib, "cdiInqKeyBytes", _wrap_cdiInqKeyBytes, -1);
+ rb_define_module_function(mCdiLib, "cdiDefKeyString", _wrap_cdiDefKeyString, -1);
+ rb_define_module_function(mCdiLib, "cdiInqKeyString", _wrap_cdiInqKeyString, -1);
+ rb_define_module_function(mCdiLib, "cdiInqKeyLen", _wrap_cdiInqKeyLen, -1);
+ rb_define_module_function(mCdiLib, "cdiCopyKeys", _wrap_cdiCopyKeys, -1);
+ rb_define_const(mCdiLib, "CDI_KEY_XNAME", SWIG_From_int((int)(901)));
+ rb_define_const(mCdiLib, "CDI_KEY_XDIMNAME", SWIG_From_int((int)(902)));
+ rb_define_const(mCdiLib, "CDI_KEY_XLONGNAME", SWIG_From_int((int)(903)));
+ rb_define_const(mCdiLib, "CDI_KEY_XUNITS", SWIG_From_int((int)(904)));
+ rb_define_const(mCdiLib, "CDI_KEY_YNAME", SWIG_From_int((int)(911)));
+ rb_define_const(mCdiLib, "CDI_KEY_YDIMNAME", SWIG_From_int((int)(912)));
+ rb_define_const(mCdiLib, "CDI_KEY_YLONGNAME", SWIG_From_int((int)(913)));
+ rb_define_const(mCdiLib, "CDI_KEY_YUNITS", SWIG_From_int((int)(914)));
+ rb_define_const(mCdiLib, "CDI_KEY_VDIMNAME", SWIG_From_int((int)(920)));
+ rb_define_const(mCdiLib, "CDI_KEY_MAPPING", SWIG_From_int((int)(921)));
+ rb_define_const(mCdiLib, "CDI_KEY_MAPNAME", SWIG_From_int((int)(922)));
+ rb_define_const(mCdiLib, "CDI_KEY_NAME", SWIG_From_int((int)(941)));
+ rb_define_const(mCdiLib, "CDI_KEY_DIMNAME", SWIG_From_int((int)(942)));
+ rb_define_const(mCdiLib, "CDI_KEY_LONGNAME", SWIG_From_int((int)(943)));
+ rb_define_const(mCdiLib, "CDI_KEY_UNITS", SWIG_From_int((int)(944)));
+ rb_define_const(mCdiLib, "CDI_KEY_PSNAME", SWIG_From_int((int)(950)));
+ rb_define_const(mCdiLib, "CDI_KEY_P0NAME", SWIG_From_int((int)(951)));
+ rb_define_const(mCdiLib, "CDI_KEY_P0VALUE", SWIG_From_int((int)(952)));
+ rb_define_module_function(mCdiLib, "cdiGridDefKeyStr", _wrap_cdiGridDefKeyStr, -1);
+ rb_define_module_function(mCdiLib, "cdiGridInqKeyStr", _wrap_cdiGridInqKeyStr, -1);
+ rb_define_module_function(mCdiLib, "cdiZaxisDefKeyStr", _wrap_cdiZaxisDefKeyStr, -1);
+ rb_define_module_function(mCdiLib, "cdiZaxisInqKeyStr", _wrap_cdiZaxisInqKeyStr, -1);
+ rb_define_module_function(mCdiLib, "cdiZaxisDefKeyFlt", _wrap_cdiZaxisDefKeyFlt, -1);
+ rb_define_module_function(mCdiLib, "cdiZaxisInqKeyFlt", _wrap_cdiZaxisInqKeyFlt, -1);
rb_define_module_function(mCdiLib, "gridDefXname", _wrap_gridDefXname, -1);
+ rb_define_module_function(mCdiLib, "gridInqXname", _wrap_gridInqXname, -1);
rb_define_module_function(mCdiLib, "gridDefXlongname", _wrap_gridDefXlongname, -1);
+ rb_define_module_function(mCdiLib, "gridInqXlongname", _wrap_gridInqXlongname, -1);
rb_define_module_function(mCdiLib, "gridDefXunits", _wrap_gridDefXunits, -1);
+ rb_define_module_function(mCdiLib, "gridInqXunits", _wrap_gridInqXunits, -1);
rb_define_module_function(mCdiLib, "gridDefYname", _wrap_gridDefYname, -1);
+ rb_define_module_function(mCdiLib, "gridInqYname", _wrap_gridInqYname, -1);
rb_define_module_function(mCdiLib, "gridDefYlongname", _wrap_gridDefYlongname, -1);
+ rb_define_module_function(mCdiLib, "gridInqYlongname", _wrap_gridInqYlongname, -1);
rb_define_module_function(mCdiLib, "gridDefYunits", _wrap_gridDefYunits, -1);
- rb_define_module_function(mCdiLib, "gridInqXname", _wrap_gridInqXname, -1);
- rb_define_module_function(mCdiLib, "gridInqXlongname", _wrap_gridInqXlongname, -1);
+ rb_define_module_function(mCdiLib, "gridInqYunits", _wrap_gridInqYunits, -1);
rb_define_module_function(mCdiLib, "gridInqXstdname", _wrap_gridInqXstdname, -1);
- rb_define_module_function(mCdiLib, "gridInqXunits", _wrap_gridInqXunits, -1);
- rb_define_module_function(mCdiLib, "gridInqYname", _wrap_gridInqYname, -1);
- rb_define_module_function(mCdiLib, "gridInqYlongname", _wrap_gridInqYlongname, -1);
rb_define_module_function(mCdiLib, "gridInqYstdname", _wrap_gridInqYstdname, -1);
- rb_define_module_function(mCdiLib, "gridInqYunits", _wrap_gridInqYunits, -1);
rb_define_module_function(mCdiLib, "gridDefDatatype", _wrap_gridDefDatatype, -1);
rb_define_module_function(mCdiLib, "gridInqDatatype", _wrap_gridInqDatatype, -1);
rb_define_module_function(mCdiLib, "gridInqXval", _wrap_gridInqXval, -1);
@@ -12063,29 +18258,24 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "gridInqXinc", _wrap_gridInqXinc, -1);
rb_define_module_function(mCdiLib, "gridInqYinc", _wrap_gridInqYinc, -1);
rb_define_module_function(mCdiLib, "gridIsCircular", _wrap_gridIsCircular, -1);
- rb_define_module_function(mCdiLib, "gridIsRotated", _wrap_gridIsRotated, -1);
- rb_define_module_function(mCdiLib, "gridInqXpole", _wrap_gridInqXpole, -1);
- rb_define_module_function(mCdiLib, "gridDefXpole", _wrap_gridDefXpole, -1);
- rb_define_module_function(mCdiLib, "gridInqYpole", _wrap_gridInqYpole, -1);
- rb_define_module_function(mCdiLib, "gridDefYpole", _wrap_gridDefYpole, -1);
- rb_define_module_function(mCdiLib, "gridInqAngle", _wrap_gridInqAngle, -1);
- rb_define_module_function(mCdiLib, "gridDefAngle", _wrap_gridDefAngle, -1);
- rb_define_module_function(mCdiLib, "gridDefTrunc", _wrap_gridDefTrunc, -1);
rb_define_module_function(mCdiLib, "gridInqTrunc", _wrap_gridInqTrunc, -1);
- rb_define_module_function(mCdiLib, "gridInqGMEnd", _wrap_gridInqGMEnd, -1);
- rb_define_module_function(mCdiLib, "gridDefGMEnd", _wrap_gridDefGMEnd, -1);
- rb_define_module_function(mCdiLib, "gridInqGMEni", _wrap_gridInqGMEni, -1);
- rb_define_module_function(mCdiLib, "gridDefGMEni", _wrap_gridDefGMEni, -1);
- rb_define_module_function(mCdiLib, "gridInqGMEni2", _wrap_gridInqGMEni2, -1);
- rb_define_module_function(mCdiLib, "gridDefGMEni2", _wrap_gridDefGMEni2, -1);
- rb_define_module_function(mCdiLib, "gridInqGMEni3", _wrap_gridInqGMEni3, -1);
- rb_define_module_function(mCdiLib, "gridDefGMEni3", _wrap_gridDefGMEni3, -1);
- rb_define_module_function(mCdiLib, "gridDefLCC", _wrap_gridDefLCC, -1);
- rb_define_module_function(mCdiLib, "gridInqLCC", _wrap_gridInqLCC, -1);
- rb_define_module_function(mCdiLib, "gridDefLcc2", _wrap_gridDefLcc2, -1);
- rb_define_module_function(mCdiLib, "gridInqLcc2", _wrap_gridInqLcc2, -1);
- rb_define_module_function(mCdiLib, "gridDefLaea", _wrap_gridDefLaea, -1);
- rb_define_module_function(mCdiLib, "gridInqLaea", _wrap_gridInqLaea, -1);
+ rb_define_module_function(mCdiLib, "gridDefTrunc", _wrap_gridDefTrunc, -1);
+ rb_define_module_function(mCdiLib, "gridDefNumber", _wrap_gridDefNumber, -1);
+ rb_define_module_function(mCdiLib, "gridInqNumber", _wrap_gridInqNumber, -1);
+ rb_define_module_function(mCdiLib, "gridDefPosition", _wrap_gridDefPosition, -1);
+ rb_define_module_function(mCdiLib, "gridInqPosition", _wrap_gridInqPosition, -1);
+ rb_define_module_function(mCdiLib, "gridDefReference", _wrap_gridDefReference, -1);
+ rb_define_module_function(mCdiLib, "gridInqReference", _wrap_gridInqReference, -1);
+ rb_define_module_function(mCdiLib, "gridDefUUID", _wrap_gridDefUUID, -1);
+ rb_define_module_function(mCdiLib, "gridInqUUID", _wrap_gridInqUUID, -1);
+ rb_define_module_function(mCdiLib, "gridDefParamRLL", _wrap_gridDefParamRLL, -1);
+ rb_define_module_function(mCdiLib, "gridInqParamRLL", _wrap_gridInqParamRLL, -1);
+ rb_define_module_function(mCdiLib, "gridDefParamGME", _wrap_gridDefParamGME, -1);
+ rb_define_module_function(mCdiLib, "gridInqParamGME", _wrap_gridInqParamGME, -1);
+ rb_define_module_function(mCdiLib, "gridDefParamLCC", _wrap_gridDefParamLCC, -1);
+ rb_define_module_function(mCdiLib, "gridInqParamLCC", _wrap_gridInqParamLCC, -1);
+ rb_define_module_function(mCdiLib, "gridDefParamSTERE", _wrap_gridDefParamSTERE, -1);
+ rb_define_module_function(mCdiLib, "gridInqParamSTERE", _wrap_gridInqParamSTERE, -1);
rb_define_module_function(mCdiLib, "gridDefArea", _wrap_gridDefArea, -1);
rb_define_module_function(mCdiLib, "gridInqArea", _wrap_gridInqArea, -1);
rb_define_module_function(mCdiLib, "gridHasArea", _wrap_gridHasArea, -1);
@@ -12093,71 +18283,101 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "gridInqNvertex", _wrap_gridInqNvertex, -1);
rb_define_module_function(mCdiLib, "gridDefXbounds", _wrap_gridDefXbounds, -1);
rb_define_module_function(mCdiLib, "gridInqXbounds", _wrap_gridInqXbounds, -1);
+ rb_define_module_function(mCdiLib, "gridInqXboundsPart", _wrap_gridInqXboundsPart, -1);
rb_define_module_function(mCdiLib, "gridDefYbounds", _wrap_gridDefYbounds, -1);
rb_define_module_function(mCdiLib, "gridInqYbounds", _wrap_gridInqYbounds, -1);
- rb_define_module_function(mCdiLib, "gridDefRowlon", _wrap_gridDefRowlon, -1);
- rb_define_module_function(mCdiLib, "gridInqRowlon", _wrap_gridInqRowlon, -1);
+ rb_define_module_function(mCdiLib, "gridInqYboundsPart", _wrap_gridInqYboundsPart, -1);
+ rb_define_module_function(mCdiLib, "gridDefReducedPoints", _wrap_gridDefReducedPoints, -1);
+ rb_define_module_function(mCdiLib, "gridInqReducedPoints", _wrap_gridInqReducedPoints, -1);
rb_define_module_function(mCdiLib, "gridChangeType", _wrap_gridChangeType, -1);
+ rb_define_module_function(mCdiLib, "gridDefComplexPacking", _wrap_gridDefComplexPacking, -1);
+ rb_define_module_function(mCdiLib, "gridInqComplexPacking", _wrap_gridInqComplexPacking, -1);
+ rb_define_module_function(mCdiLib, "gridDefScanningMode", _wrap_gridDefScanningMode, -1);
+ rb_define_module_function(mCdiLib, "gridInqScanningMode", _wrap_gridInqScanningMode, -1);
rb_define_module_function(mCdiLib, "zaxisName", _wrap_zaxisName, -1);
+ rb_define_module_function(mCdiLib, "zaxisNamePtr", _wrap_zaxisNamePtr, -1);
rb_define_module_function(mCdiLib, "zaxisCreate", _wrap_zaxisCreate, -1);
rb_define_module_function(mCdiLib, "zaxisDestroy", _wrap_zaxisDestroy, -1);
rb_define_module_function(mCdiLib, "zaxisInqType", _wrap_zaxisInqType, -1);
rb_define_module_function(mCdiLib, "zaxisInqSize", _wrap_zaxisInqSize, -1);
rb_define_module_function(mCdiLib, "zaxisDuplicate", _wrap_zaxisDuplicate, -1);
- rb_define_module_function(mCdiLib, "zaxisResize", _wrap_zaxisResize, -1);
- rb_define_module_function(mCdiLib, "zaxisPrint", _wrap_zaxisPrint, -1);
- rb_define_module_function(mCdiLib, "zaxisSize", _wrap_zaxisSize, -1);
rb_define_module_function(mCdiLib, "zaxisDefLevels", _wrap_zaxisDefLevels, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefCvals", _wrap_zaxisDefCvals, -1);
rb_define_module_function(mCdiLib, "zaxisInqLevels", _wrap_zaxisInqLevels, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqCLen", _wrap_zaxisInqCLen, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqCVals", _wrap_zaxisInqCVals, -1);
rb_define_module_function(mCdiLib, "zaxisDefLevel", _wrap_zaxisDefLevel, -1);
rb_define_module_function(mCdiLib, "zaxisInqLevel", _wrap_zaxisInqLevel, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefNlevRef", _wrap_zaxisDefNlevRef, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqNlevRef", _wrap_zaxisInqNlevRef, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefNumber", _wrap_zaxisDefNumber, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqNumber", _wrap_zaxisInqNumber, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefUUID", _wrap_zaxisDefUUID, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqUUID", _wrap_zaxisInqUUID, -1);
rb_define_module_function(mCdiLib, "zaxisDefName", _wrap_zaxisDefName, -1);
- rb_define_module_function(mCdiLib, "zaxisDefLongname", _wrap_zaxisDefLongname, -1);
- rb_define_module_function(mCdiLib, "zaxisDefUnits", _wrap_zaxisDefUnits, -1);
rb_define_module_function(mCdiLib, "zaxisInqName", _wrap_zaxisInqName, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefLongname", _wrap_zaxisDefLongname, -1);
rb_define_module_function(mCdiLib, "zaxisInqLongname", _wrap_zaxisInqLongname, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefUnits", _wrap_zaxisDefUnits, -1);
rb_define_module_function(mCdiLib, "zaxisInqUnits", _wrap_zaxisInqUnits, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqStdname", _wrap_zaxisInqStdname, -1);
rb_define_module_function(mCdiLib, "zaxisDefDatatype", _wrap_zaxisDefDatatype, -1);
rb_define_module_function(mCdiLib, "zaxisInqDatatype", _wrap_zaxisInqDatatype, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefPositive", _wrap_zaxisDefPositive, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqPositive", _wrap_zaxisInqPositive, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefScalar", _wrap_zaxisDefScalar, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqScalar", _wrap_zaxisInqScalar, -1);
rb_define_module_function(mCdiLib, "zaxisDefLtype", _wrap_zaxisDefLtype, -1);
rb_define_module_function(mCdiLib, "zaxisInqLtype", _wrap_zaxisInqLtype, -1);
- rb_define_module_function(mCdiLib, "zaxisInqLevelsPtr", _wrap_zaxisInqLevelsPtr, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefLtype2", _wrap_zaxisDefLtype2, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqLtype2", _wrap_zaxisInqLtype2, -1);
rb_define_module_function(mCdiLib, "zaxisDefVct", _wrap_zaxisDefVct, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqVct", _wrap_zaxisInqVct, -1);
rb_define_module_function(mCdiLib, "zaxisInqVctSize", _wrap_zaxisInqVctSize, -1);
rb_define_module_function(mCdiLib, "zaxisInqVctPtr", _wrap_zaxisInqVctPtr, -1);
+ rb_define_module_function(mCdiLib, "zaxisDefLbounds", _wrap_zaxisDefLbounds, -1);
rb_define_module_function(mCdiLib, "zaxisInqLbounds", _wrap_zaxisInqLbounds, -1);
- rb_define_module_function(mCdiLib, "zaxisInqUbounds", _wrap_zaxisInqUbounds, -1);
- rb_define_module_function(mCdiLib, "zaxisInqWeights", _wrap_zaxisInqWeights, -1);
rb_define_module_function(mCdiLib, "zaxisInqLbound", _wrap_zaxisInqLbound, -1);
- rb_define_module_function(mCdiLib, "zaxisInqUbound", _wrap_zaxisInqUbound, -1);
- rb_define_module_function(mCdiLib, "zaxisDefLbounds", _wrap_zaxisDefLbounds, -1);
rb_define_module_function(mCdiLib, "zaxisDefUbounds", _wrap_zaxisDefUbounds, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqUbounds", _wrap_zaxisInqUbounds, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqUbound", _wrap_zaxisInqUbound, -1);
rb_define_module_function(mCdiLib, "zaxisDefWeights", _wrap_zaxisDefWeights, -1);
+ rb_define_module_function(mCdiLib, "zaxisInqWeights", _wrap_zaxisInqWeights, -1);
rb_define_module_function(mCdiLib, "zaxisChangeType", _wrap_zaxisChangeType, -1);
rb_define_module_function(mCdiLib, "taxisCreate", _wrap_taxisCreate, -1);
rb_define_module_function(mCdiLib, "taxisDestroy", _wrap_taxisDestroy, -1);
rb_define_module_function(mCdiLib, "taxisDuplicate", _wrap_taxisDuplicate, -1);
rb_define_module_function(mCdiLib, "taxisCopyTimestep", _wrap_taxisCopyTimestep, -1);
rb_define_module_function(mCdiLib, "taxisDefType", _wrap_taxisDefType, -1);
+ rb_define_module_function(mCdiLib, "taxisInqType", _wrap_taxisInqType, -1);
rb_define_module_function(mCdiLib, "taxisDefVdate", _wrap_taxisDefVdate, -1);
rb_define_module_function(mCdiLib, "taxisDefVtime", _wrap_taxisDefVtime, -1);
+ rb_define_module_function(mCdiLib, "taxisInqVdate", _wrap_taxisInqVdate, -1);
+ rb_define_module_function(mCdiLib, "taxisInqVtime", _wrap_taxisInqVtime, -1);
rb_define_module_function(mCdiLib, "taxisDefRdate", _wrap_taxisDefRdate, -1);
rb_define_module_function(mCdiLib, "taxisDefRtime", _wrap_taxisDefRtime, -1);
+ rb_define_module_function(mCdiLib, "taxisInqRdate", _wrap_taxisInqRdate, -1);
+ rb_define_module_function(mCdiLib, "taxisInqRtime", _wrap_taxisInqRtime, -1);
+ rb_define_module_function(mCdiLib, "taxisDefFdate", _wrap_taxisDefFdate, -1);
+ rb_define_module_function(mCdiLib, "taxisDefFtime", _wrap_taxisDefFtime, -1);
+ rb_define_module_function(mCdiLib, "taxisInqFdate", _wrap_taxisInqFdate, -1);
+ rb_define_module_function(mCdiLib, "taxisInqFtime", _wrap_taxisInqFtime, -1);
rb_define_module_function(mCdiLib, "taxisHasBounds", _wrap_taxisHasBounds, -1);
+ rb_define_module_function(mCdiLib, "taxisWithBounds", _wrap_taxisWithBounds, -1);
+ rb_define_module_function(mCdiLib, "taxisDeleteBounds", _wrap_taxisDeleteBounds, -1);
rb_define_module_function(mCdiLib, "taxisDefVdateBounds", _wrap_taxisDefVdateBounds, -1);
rb_define_module_function(mCdiLib, "taxisDefVtimeBounds", _wrap_taxisDefVtimeBounds, -1);
rb_define_module_function(mCdiLib, "taxisInqVdateBounds", _wrap_taxisInqVdateBounds, -1);
rb_define_module_function(mCdiLib, "taxisInqVtimeBounds", _wrap_taxisInqVtimeBounds, -1);
rb_define_module_function(mCdiLib, "taxisDefCalendar", _wrap_taxisDefCalendar, -1);
- rb_define_module_function(mCdiLib, "taxisDefTunit", _wrap_taxisDefTunit, -1);
- rb_define_module_function(mCdiLib, "taxisDefNumavg", _wrap_taxisDefNumavg, -1);
- rb_define_module_function(mCdiLib, "taxisInqType", _wrap_taxisInqType, -1);
- rb_define_module_function(mCdiLib, "taxisInqVdate", _wrap_taxisInqVdate, -1);
- rb_define_module_function(mCdiLib, "taxisInqVtime", _wrap_taxisInqVtime, -1);
- rb_define_module_function(mCdiLib, "taxisInqRdate", _wrap_taxisInqRdate, -1);
- rb_define_module_function(mCdiLib, "taxisInqRtime", _wrap_taxisInqRtime, -1);
rb_define_module_function(mCdiLib, "taxisInqCalendar", _wrap_taxisInqCalendar, -1);
+ rb_define_module_function(mCdiLib, "taxisDefTunit", _wrap_taxisDefTunit, -1);
rb_define_module_function(mCdiLib, "taxisInqTunit", _wrap_taxisInqTunit, -1);
+ rb_define_module_function(mCdiLib, "taxisDefForecastTunit", _wrap_taxisDefForecastTunit, -1);
+ rb_define_module_function(mCdiLib, "taxisInqForecastTunit", _wrap_taxisInqForecastTunit, -1);
+ rb_define_module_function(mCdiLib, "taxisDefForecastPeriod", _wrap_taxisDefForecastPeriod, -1);
+ rb_define_module_function(mCdiLib, "taxisInqForecastPeriod", _wrap_taxisInqForecastPeriod, -1);
+ rb_define_module_function(mCdiLib, "taxisDefNumavg", _wrap_taxisDefNumavg, -1);
rb_define_module_function(mCdiLib, "taxisInqNumavg", _wrap_taxisInqNumavg, -1);
rb_define_module_function(mCdiLib, "tunitNamePtr", _wrap_tunitNamePtr, -1);
rb_define_module_function(mCdiLib, "institutDef", _wrap_institutDef, -1);
@@ -12172,35 +18392,32 @@ SWIGEXPORT void Init_CdiLib(void) {
rb_define_module_function(mCdiLib, "modelInqInstitut", _wrap_modelInqInstitut, -1);
rb_define_module_function(mCdiLib, "modelInqGribID", _wrap_modelInqGribID, -1);
rb_define_module_function(mCdiLib, "modelInqNamePtr", _wrap_modelInqNamePtr, -1);
- rb_define_module_function(mCdiLib, "tableWriteC", _wrap_tableWriteC, -1);
+ rb_define_module_function(mCdiLib, "tableFWriteC", _wrap_tableFWriteC, -1);
rb_define_module_function(mCdiLib, "tableWrite", _wrap_tableWrite, -1);
rb_define_module_function(mCdiLib, "tableRead", _wrap_tableRead, -1);
rb_define_module_function(mCdiLib, "tableDef", _wrap_tableDef, -1);
rb_define_module_function(mCdiLib, "tableInqNamePtr", _wrap_tableInqNamePtr, -1);
- rb_define_module_function(mCdiLib, "tableDefEntry", _wrap_tableDefEntry, -1);
rb_define_module_function(mCdiLib, "tableInq", _wrap_tableInq, -1);
rb_define_module_function(mCdiLib, "tableInqNumber", _wrap_tableInqNumber, -1);
rb_define_module_function(mCdiLib, "tableInqNum", _wrap_tableInqNum, -1);
rb_define_module_function(mCdiLib, "tableInqModel", _wrap_tableInqModel, -1);
- rb_define_module_function(mCdiLib, "tableInqPar", _wrap_tableInqPar, -1);
- rb_define_module_function(mCdiLib, "tableInqParCode", _wrap_tableInqParCode, -1);
- rb_define_module_function(mCdiLib, "tableInqParName", _wrap_tableInqParName, -1);
- rb_define_module_function(mCdiLib, "tableInqParLongname", _wrap_tableInqParLongname, -1);
- rb_define_module_function(mCdiLib, "tableInqParUnits", _wrap_tableInqParUnits, -1);
- rb_define_module_function(mCdiLib, "tableInqParNamePtr", _wrap_tableInqParNamePtr, -1);
- rb_define_module_function(mCdiLib, "tableInqParLongnamePtr", _wrap_tableInqParLongnamePtr, -1);
- rb_define_module_function(mCdiLib, "tableInqParUnitsPtr", _wrap_tableInqParUnitsPtr, -1);
+ rb_define_module_function(mCdiLib, "tableInqEntry", _wrap_tableInqEntry, -1);
rb_define_module_function(mCdiLib, "streamDefHistory", _wrap_streamDefHistory, -1);
rb_define_module_function(mCdiLib, "streamInqHistorySize", _wrap_streamInqHistorySize, -1);
rb_define_module_function(mCdiLib, "streamInqHistoryString", _wrap_streamInqHistoryString, -1);
+ rb_define_module_function(mCdiLib, "subtypeCreate", _wrap_subtypeCreate, -1);
+ rb_define_module_function(mCdiLib, "subtypePrint", _wrap_subtypePrint, -1);
+ rb_define_module_function(mCdiLib, "subtypeCompare", _wrap_subtypeCompare, -1);
+ rb_define_module_function(mCdiLib, "subtypeInqSize", _wrap_subtypeInqSize, -1);
+ rb_define_module_function(mCdiLib, "subtypeInqActiveIndex", _wrap_subtypeInqActiveIndex, -1);
+ rb_define_module_function(mCdiLib, "subtypeDefActiveIndex", _wrap_subtypeDefActiveIndex, -1);
+ rb_define_module_function(mCdiLib, "keyValuePair", _wrap_keyValuePair, -1);
+ rb_define_module_function(mCdiLib, "matchAND", _wrap_matchAND, -1);
+ rb_define_module_function(mCdiLib, "subtypeInqSubEntry", _wrap_subtypeInqSubEntry, -1);
+ rb_define_module_function(mCdiLib, "subtypeInqTile", _wrap_subtypeInqTile, -1);
+ rb_define_module_function(mCdiLib, "subtypeInqAttribute", _wrap_subtypeInqAttribute, -1);
+ rb_define_module_function(mCdiLib, "vlistInqVarSubtype", _wrap_vlistInqVarSubtype, -1);
+ rb_define_module_function(mCdiLib, "gribapiLibraryVersion", _wrap_gribapiLibraryVersion, -1);
+ rb_define_module_function(mCdiLib, "gaussianLatitudes", _wrap_gaussianLatitudes, -1);
}
-/*
- * Local Variables:
- * c-file-style: "Java"
- * c-basic-offset: 2
- * indent-tabs-mode: nil
- * show-trailing-whitespace: t
- * require-trailing-newline: t
- * End:
- */
diff --git a/interfaces/ruby/cdiobj_wrap.cpp b/interfaces/ruby/cdiobj_wrap.cpp
index e7d3f1b9c..c4de6ee89 100644
--- a/interfaces/ruby/cdiobj_wrap.cpp
+++ b/interfaces/ruby/cdiobj_wrap.cpp
@@ -29009,7 +29009,7 @@ _wrap_CdiTaxis_name_set(int argc, VALUE *argv, VALUE self) {
char *arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
- char temp2[128] ;
+ char temp2[CDI_MAX_NAME] ;
int res2 ;
if ((argc < 1) || (argc > 1)) {
@@ -29020,13 +29020,13 @@ _wrap_CdiTaxis_name_set(int argc, VALUE *argv, VALUE self) {
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CdiTaxis *","name", 1, self ));
}
arg1 = reinterpret_cast< CdiTaxis * >(argp1);
- res2 = SWIG_AsCharArray(argv[0], temp2, 128);
+ res2 = SWIG_AsCharArray(argv[0], temp2, CDI_MAX_NAME);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [128]","name", 2, argv[0] ));
+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [CDI_MAX_NAME]","name", 2, argv[0] ));
}
arg2 = reinterpret_cast< char * >(temp2);
- if (arg2) memcpy(arg1->name,arg2,128*sizeof(char));
- else memset(arg1->name,0,128*sizeof(char));
+ if (arg2) memcpy(arg1->name,arg2,CDI_MAX_NAME*sizeof(char));
+ else memset(arg1->name,0,CDI_MAX_NAME*sizeof(char));
return Qnil;
fail:
return Qnil;
@@ -29051,7 +29051,7 @@ _wrap_CdiTaxis_name_get(int argc, VALUE *argv, VALUE self) {
arg1 = reinterpret_cast< CdiTaxis * >(argp1);
result = (char *)(char *) ((arg1)->name);
{
- size_t size = SWIG_strnlen(result, 128);
+ size_t size = SWIG_strnlen(result, CDI_MAX_NAME);
@@ -33568,7 +33568,6 @@ SWIGEXPORT void Init_CdiObj(void) {
SwigClassGridsMap.mark = 0;
SwigClassGridsMap.destroy = (void (*)(void *)) free_std_map_Sl_int_Sc_CdiGrid_Sg_;
SwigClassGridsMap.trackObjects = 0;
- rb_define_const(mCdiObj, "CHARSIZE", SWIG_From_int(static_cast< int >(128)));
SwigClassCdiGrid.klass = rb_define_class_under(mCdiObj, "CdiGrid", rb_cObject);
SWIG_TypeClientData(SWIGTYPE_p_CdiGrid, (void *) &SwigClassCdiGrid);
diff --git a/interfaces/ruby/testLib.rb b/interfaces/ruby/testLib.rb
index 41556487e..b1e02f46d 100644
--- a/interfaces/ruby/testLib.rb
+++ b/interfaces/ruby/testLib.rb
@@ -1,4 +1,4 @@
-require 'CdiLib'
+require './CdiLib'
include CdiLib
ifile = ARGV[0].nil? ? "../testdata/mulval.nc" : ARGV[0]
streamID = streamOpenRead(ifile)
--
GitLab