diff --git a/libs/gempa/caps/CMakeLists.txt b/libs/gempa/caps/CMakeLists.txt index 46741c8..3b6931a 100644 --- a/libs/gempa/caps/CMakeLists.txt +++ b/libs/gempa/caps/CMakeLists.txt @@ -16,7 +16,7 @@ INCLUDE_DIRECTORIES(../../3rd-party/mseed) ADD_LIBRARY(${LIB_NAME} SHARED ${${PACKAGE_NAME}_SOURCES}) SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES COMPILE_FLAGS -fPIC) -SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES VERSION 1.0.0 SOVERSION 1) +SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES VERSION 2.0.0 SOVERSION 2) TARGET_LINK_LIBRARIES(${LIB_NAME} mseed) INSTALL(TARGETS ${LIB_NAME} DESTINATION lib) diff --git a/libs/gempa/caps/encoderfactory.cpp b/libs/gempa/caps/encoderfactory.cpp index 86f228d..554f2ce 100644 --- a/libs/gempa/caps/encoderfactory.cpp +++ b/libs/gempa/caps/encoderfactory.cpp @@ -39,7 +39,7 @@ const string& EncoderFactory::errorString() const { MSEEDEncoderFactory::MSEEDEncoderFactory() : _recordLength(9) {} -bool MSEEDEncoderFactory::setRecordLength(uint recordLength) { +bool MSEEDEncoderFactory::setRecordLength(unsigned int recordLength) { if ( recordLength < 7 || recordLength > 32) { _errorString = "MSEED record length out of range [7, 32]"; return false; diff --git a/libs/gempa/caps/encoderfactory.h b/libs/gempa/caps/encoderfactory.h index c4e085e..1c72b03 100644 --- a/libs/gempa/caps/encoderfactory.h +++ b/libs/gempa/caps/encoderfactory.h @@ -84,7 +84,7 @@ class MSEEDEncoderFactory : public EncoderFactory { * @param recLen The record length expressed as a power of 2 * @return True if the record length is valid */ - bool setRecordLength(uint recordLength); + bool setRecordLength(unsigned int recordLength); protected: uint8_t _recordLength; diff --git a/libs/gempa/caps/mseed/encoder.h b/libs/gempa/caps/mseed/encoder.h index 5c8d037..26c4322 100644 --- a/libs/gempa/caps/mseed/encoder.h +++ b/libs/gempa/caps/mseed/encoder.h @@ -44,10 +44,10 @@ class Encoder { virtual void reset() { _sampleCount = 0; } virtual int type() const = 0; - const SPClock& clk() { return _clk; } + const SPClock &clk() { return _clk; } - void setStartTime(const SPClock::INT_TIME &time) { _clk.sync_time(time); } - const SPClock::INT_TIME currentTime() const { return _clk.get_time(0); } + void setStartTime(const Time &time) { _clk.syncTime(time); } + const Time currentTime() const { return _clk.getTime(0); } int timingQuality() { return _timingQuality; } void setTimingQuality(int quality) { _timingQuality = quality; } diff --git a/libs/gempa/caps/mseed/mseed.cpp b/libs/gempa/caps/mseed/mseed.cpp index 8b96648..a3d2113 100644 --- a/libs/gempa/caps/mseed/mseed.cpp +++ b/libs/gempa/caps/mseed/mseed.cpp @@ -18,7 +18,6 @@ *****************************************************************************/ #include -#include #include "mseed.h" #include "slink.h" @@ -27,23 +26,26 @@ #include #include #include -#include #include #include - namespace Gempa { namespace CAPS { + MSEEDFormat::MSEEDFormat(const std::string &netcode, const std::string &stacode, const std::string &loccode, const std::string &chacode, unsigned short freqn, unsigned short freqd, - unsigned short packtype_init, + unsigned short packType, uint8_t recordLength) - : networkCode(netcode), stationCode(stacode), locationCode(loccode), - channelCode(chacode), packType(packtype_init), recordLength(recordLength) +: networkCode(netcode) +, stationCode(stacode) +, locationCode(loccode) +, channelCode(chacode) +, packType(packType) +, recordLength(recordLength) { if(freqn == 0 || freqd == 0) { sample_rate_factor = 0; @@ -63,8 +65,10 @@ MSEEDFormat::MSEEDFormat(const std::string &netcode, const std::string &stacode, } } -MSEEDDataRecord *MSEEDFormat::get_buffer(const SPClock::INT_TIME &it, int usec_correction, - int timing_quality, void *&dataptr, int &datalen) { + +MSEEDDataRecord *MSEEDFormat::getBuffer(const Time &it, int usec_correction, + int timing_quality, void *&dataptr, + int &datalen) { size_t buflen = 1 << recordLength; MSEEDDataRecord *record = new MSEEDDataRecord(); record->data()->resize(buflen); @@ -151,12 +155,10 @@ void MSEEDFormat::updateBuffer(MSEEDDataRecord *rec, int samples, int frames) { if ( ntohs(blkt_1000->next_blkt) != 0 ) { sl_blkt_1001_s* blkt_1001 = (sl_blkt_1001_s *)((char *) fsdh + sizeof(sl_fsdh_s) + sizeof(sl_blkt_1000_s)); - blkt_1001->frame_cnt = frames; } - - rec->unpackHeader(); } + } } diff --git a/libs/gempa/caps/mseed/mseed.h b/libs/gempa/caps/mseed/mseed.h index 48f656a..f0550c9 100644 --- a/libs/gempa/caps/mseed/mseed.h +++ b/libs/gempa/caps/mseed/mseed.h @@ -58,16 +58,16 @@ struct MSEEDFormat { template MSEEDEncoderPacket - get_packet(const SPClock::INT_TIME &it, int usec_correction, int timing_quality) { + getPacket(const Time &it, int usec_correction, int timing_quality) { void *dataptr = NULL; int datalen = 0; unsigned int size = 0; - MSEEDDataRecord *rec = get_buffer(it, usec_correction, timing_quality, dataptr, datalen); + MSEEDDataRecord *rec = getBuffer(it, usec_correction, timing_quality, dataptr, datalen); return MSEEDEncoderPacket(rec, size, dataptr, datalen); } - MSEEDDataRecord *get_buffer(const SPClock::INT_TIME &it, int usec_correction, + MSEEDDataRecord *getBuffer(const Time &it, int usec_correction, int timing_quality, void *&dataptr, int &datalen); diff --git a/libs/gempa/caps/mseed/spclock.h b/libs/gempa/caps/mseed/spclock.h index 3719899..5f07ade 100644 --- a/libs/gempa/caps/mseed/spclock.h +++ b/libs/gempa/caps/mseed/spclock.h @@ -17,6 +17,7 @@ * 01.01.2013 Adapted code to CAPS client library requirements (gempa GmbH) *****************************************************************************/ + #ifndef CAPS_MSEED_SPCLOCK_H #define CAPS_MSEED_SPCLOCK_H @@ -28,51 +29,43 @@ namespace Gempa { namespace CAPS { -class SPClock - { - public: - typedef Gempa::CAPS::Time INT_TIME; - - private: - INT_TIME itime; - int ticks; - int corr; +class SPClock { + public: + SPClock(int freqn, int freqd) + : freqn(freqn), freqd(freqd) {} - public: - const int freqn; - const int freqd; + void syncTime(const Time &time) { + _itime = time; + _ticks = 0; + _corr = 0; + } - SPClock(int freqn_init, int freqd_init): ticks(0), corr(0), - freqn(freqn_init), freqd(freqd_init) - {} + void tick() { + ++_ticks; + } - void sync_time(const INT_TIME &time) - { - itime = time; - ticks = 0; - corr = 0; - } + Time getTime(int tickDiff) const { + int64_t correctness = (double)freqd / (double)freqn * 1000000 * (_ticks - tickDiff - _corr); + return _itime + TimeSpan(long(correctness / 1000000), long(correctness % 1000000)); + } - void tick() - { - ++ticks; - } + int correction() const { + return _corr; + } - INT_TIME get_time(int tick_diff) const - { - int64_t correctness = (double)freqd / (double)freqn * 1000000 * (ticks - tick_diff - corr); - return itime + Gempa::CAPS::TimeSpan(long(correctness/1000000),long(correctness%1000000)); - } + public: + const int freqn; + const int freqd; - int correction() const - { - return corr; - } - }; + private: + Time _itime; + int _ticks{0}; + int _corr{0}; +}; } } -#endif // SPCLOCK_H +#endif diff --git a/libs/gempa/caps/mseed/steim1.h b/libs/gempa/caps/mseed/steim1.h index a4f0d74..7398d60 100644 --- a/libs/gempa/caps/mseed/steim1.h +++ b/libs/gempa/caps/mseed/steim1.h @@ -33,8 +33,8 @@ namespace CAPS { //***************************************************************************** struct Steim1Frame { - u_int32_t nibble_word; - u_int32_t sample_word[15]; + u_int32_t nibbleWord; + u_int32_t sampleWord[15]; }; //***************************************************************************** @@ -43,42 +43,44 @@ struct Steim1Frame { template class Steim1Encoder: public Encoder { + public: + Steim1Encoder(MSEEDFormat *format, int freqn, int freqd) + : Encoder(freqn, freqd), _format(format), _frameCount(0) + , _bp(0), _fp(0), _spw(4), _lastSample(0), _nibbleWord(0) {} + virtual ~Steim1Encoder(); + + virtual void flush(); + virtual void push(void *value); + virtual int type() const { return DE_STEIM1; } + private: - MSEEDFormat *format; - int frame_count; - int bp; - int fp; - int spw; - int32_t last_sample; - int32_t buf[5]; - u_int32_t nibble_word; - MSEEDEncoderPacket current_packet; - - void update_spw(int bp); + void updateSpw(int bp); void store(int32_t value); - void init_packet(); - void finish_packet(); - void update_packet(); + void initPacket(); + void updatePacket(); + void finishPacket(); - MSEEDEncoderPacket get_packet() { - return format->get_packet(_clk.get_time(bp), + MSEEDEncoderPacket getPacket() { + return _format->getPacket(_clk.getTime(_bp), _clk.correction(), _timingQuality); } - void queue_packet(MSEEDEncoderPacket &pckt); + void queuePacket(MSEEDEncoderPacket &pckt); - int number_of_frames(const MSEEDEncoderPacket &packet) { + int numberOfFrames(const MSEEDEncoderPacket &packet) { return (packet.datalen >> 6); } - public: - Steim1Encoder(MSEEDFormat *format, int freqn, int freqd) - : Encoder(freqn, freqd), format(format), frame_count(0), - bp(0), fp(0), spw(4), last_sample(0), nibble_word(0) {} - virtual ~Steim1Encoder(); - virtual void flush(); - virtual void push(void *value); - virtual int type() const { return DE_STEIM1; } + private: + MSEEDFormat *_format; + int _frameCount; + int _bp; + int _fp; + int _spw; + int32_t _lastSample; + int32_t _buf[5]; + u_int32_t _nibbleWord; + MSEEDEncoderPacket _currentPacket; }; diff --git a/libs/gempa/caps/mseed/steim1.ipp b/libs/gempa/caps/mseed/steim1.ipp index d454ca0..e126705 100644 --- a/libs/gempa/caps/mseed/steim1.ipp +++ b/libs/gempa/caps/mseed/steim1.ipp @@ -27,158 +27,181 @@ namespace Gempa { namespace CAPS { -template Steim1Encoder::~Steim1Encoder() { - if ( format != NULL ) delete format; +template +Steim1Encoder::~Steim1Encoder() { + if ( _format ) { + delete _format; + } } -template void Steim1Encoder::update_spw(int bp) { +template +void Steim1Encoder::updateSpw(int bp) { int spw1 = 4; assert(bp < 4); - if(buf[bp] < -32768 || buf[bp] > 32767) spw1 = 1; - else if(buf[bp] < -128 || buf[bp] > 127) spw1 = 2; - if(spw1 < spw) spw = spw1; + if ( _buf[bp] < -32768 || _buf[bp] > 32767 ) spw1 = 1; + else if ( _buf[bp] < -128 || _buf[bp] > 127 ) spw1 = 2; + if ( spw1 < _spw ) _spw = spw1; } -template void Steim1Encoder::store(int32_t value) { - assert(bp < 4); - buf[bp] = value - last_sample; - last_sample = value; - update_spw(bp); - ++bp; +template +void Steim1Encoder::store(int32_t value) { + assert(_bp < 4); + _buf[_bp] = value - _lastSample; + _lastSample = value; + updateSpw(_bp); + ++_bp; } -template void Steim1Encoder::init_packet() { +template +void Steim1Encoder::initPacket() { int i; - int32_t begin_sample = last_sample; + int32_t beginSample = _lastSample; - for(i = 1; i < bp; ++i) { - begin_sample -= buf[i]; + for ( i = 1; i < _bp; ++i ) { + beginSample -= _buf[i]; } reset(); - current_packet.data[0].sample_word[0] = htonl(begin_sample); - frame_count = 0; - nibble_word = 0; - fp = 2; + _currentPacket.data[0].sampleWord[0] = htonl(beginSample); + _frameCount = 0; + _nibbleWord = 0; + _fp = 2; } -template void Steim1Encoder::finish_packet() { +template +void Steim1Encoder::finishPacket() { int i; - int32_t end_sample = last_sample; + int32_t endSample = _lastSample; - for(i = 0; i < bp; ++i) { - end_sample -= buf[i]; + for ( i = 0; i < _bp; ++i ) { + endSample -= _buf[i]; } - current_packet.data[0].sample_word[1] = htonl(end_sample); + _currentPacket.data[0].sampleWord[1] = htonl(endSample); } -template void Steim1Encoder::update_packet() { +template +void Steim1Encoder::updatePacket() { unsigned int nibble = 0; - u_int32_t sample_word = 0; + u_int32_t sampleWord = 0; - assert(bp < 5); + assert(_bp < 5); - int used = bp; + int used = _bp; - while(used > spw) { + while ( used > _spw ) { --used; - spw = 4; - for(int i = 0; i < used; ++i) update_spw(i); + _spw = 4; + for ( int i = 0; i < used; ++i ) { + updateSpw(i); + } } - while(used < spw) spw >>= 1; + while ( used < _spw ) { + _spw >>= 1; + } - used = spw; + used = _spw; - switch(spw) { + switch ( _spw ) { case 4: nibble = 1; - sample_word = ((buf[0] & 0xff) << 24) | ((buf[1] & 0xff) << 16) | - ((buf[2] & 0xff) << 8) | (buf[3] & 0xff); + sampleWord = ((_buf[0] & 0xff) << 24) | ((_buf[1] & 0xff) << 16) | + ((_buf[2] & 0xff) << 8) | (_buf[3] & 0xff); break; case 2: nibble = 2; - sample_word = ((buf[0] & 0xffff) << 16) | (buf[1] & 0xffff); + sampleWord = ((_buf[0] & 0xffff) << 16) | (_buf[1] & 0xffff); break; case 1: nibble = 3; - sample_word = buf[0]; + sampleWord = _buf[0]; break; default: assert(0); } - nibble_word |= (nibble << (30 - ((fp + 1) << 1))); + _nibbleWord |= (nibble << (30 - ((_fp + 1) << 1))); - spw = 4; - for(int i = 0; i < bp - used; ++i) { - buf[i] = buf[i + used]; - update_spw(i); + _spw = 4; + for ( int i = 0; i < _bp - used; ++i ) { + _buf[i] = _buf[i + used]; + updateSpw(i); } - bp -= used; + _bp -= used; _sampleCount += used; - current_packet.data[frame_count].nibble_word = htonl(nibble_word); - current_packet.data[frame_count].sample_word[fp] = htonl(sample_word); - if(++fp < 15) return; + _currentPacket.data[_frameCount].nibbleWord = htonl(_nibbleWord); + _currentPacket.data[_frameCount].sampleWord[_fp] = htonl(sampleWord); + + if ( ++_fp < 15 ) { + return; + } + + _nibbleWord = 0; + _fp = 0; + ++_frameCount; - nibble_word = 0; - fp = 0; - ++frame_count; return; } -template void Steim1Encoder::queue_packet(MSEEDEncoderPacket &pckt) { - format->updateBuffer(pckt.record, _sampleCount, frame_count + (fp > 0)); +template +void Steim1Encoder::queuePacket(MSEEDEncoderPacket &pckt) { + _format->updateBuffer(pckt.record, _sampleCount, _frameCount + (_fp > 0)); - Packet *packet = new Packet(DataRecordPtr(pckt.record), format->networkCode, format->stationCode, - format->locationCode, format->channelCode); + Packet *packet = new Packet(DataRecordPtr(pckt.record), + _format->networkCode, + _format->stationCode, + _format->locationCode, + _format->channelCode); _packetQueue.push_back(PacketPtr(packet)); pckt.reset(); reset(); } -template void Steim1Encoder::push(void *value) { +template +void Steim1Encoder::push(void *value) { int32_t sample_val = *static_cast(value); store(sample_val); _clk.tick(); - while(bp >= spw) { - if(!current_packet.valid()) { - current_packet = get_packet(); - init_packet(); + while ( _bp >= _spw ) { + if ( !_currentPacket.valid() ) { + _currentPacket = getPacket(); + initPacket(); } - update_packet(); - if(frame_count == number_of_frames(current_packet)) { - finish_packet(); - queue_packet(current_packet); + updatePacket(); + if ( _frameCount == numberOfFrames(_currentPacket) ) { + finishPacket(); + queuePacket(_currentPacket); } } } -template void Steim1Encoder::flush() { - while(bp) { - if(!current_packet.valid()) { - current_packet = get_packet(); - init_packet(); +template +void Steim1Encoder::flush() { + while ( _bp ) { + if ( !_currentPacket.valid() ) { + _currentPacket = getPacket(); + initPacket(); } - update_packet(); - if(frame_count == number_of_frames(current_packet)) { - finish_packet(); - queue_packet(current_packet); + updatePacket(); + if ( _frameCount == numberOfFrames(_currentPacket) ) { + finishPacket(); + queuePacket(_currentPacket); } } - if(current_packet.valid()) { - finish_packet(); - queue_packet(current_packet); + if ( _currentPacket.valid() ) { + finishPacket(); + queuePacket(_currentPacket); } } + } } diff --git a/libs/gempa/caps/mseed/steim2.h b/libs/gempa/caps/mseed/steim2.h index 46bcd98..9e69371 100644 --- a/libs/gempa/caps/mseed/steim2.h +++ b/libs/gempa/caps/mseed/steim2.h @@ -31,8 +31,8 @@ namespace CAPS { //***************************************************************************** struct Steim2Frame { - u_int32_t nibble_word; - u_int32_t sample_word[15]; + u_int32_t nibbleWord; + u_int32_t sampleWord[15]; }; //***************************************************************************** @@ -43,8 +43,8 @@ template class Steim2Encoder : public Encoder { public: Steim2Encoder(MSEEDFormat *format, int freqn, int freqd) - : Encoder(freqn, freqd), format(format), frame_count(0), - bp(0), fp(0), spw(4), last_sample(0), nibble_word(0) { + : Encoder(freqn, freqd), _format(format), _frameCount(0) + , _bp(0), _fp(0), _spw(4), _lastSample(0), _nibbleWord(0) { } virtual ~Steim2Encoder(); virtual void flush(); @@ -53,34 +53,34 @@ class Steim2Encoder : public Encoder { virtual int type() const { return DE_STEIM2; } private: - void update_spw(int bp); + void updateSpw(int bp); void store(int32_t value); - void init_packet(); - void finish_packet(); - void update_packet(); + void initPacket(); + void updatePacket(); + void finishPacket(); - MSEEDEncoderPacket get_packet() { - return format->get_packet(_clk.get_time(bp), + MSEEDEncoderPacket getPacket() { + return _format->getPacket(_clk.getTime(_bp), _clk.correction(), _timingQuality); } - void queue_packet(MSEEDEncoderPacket &pckt); + void queuePacket(MSEEDEncoderPacket &pckt); - int number_of_frames(const MSEEDEncoderPacket &packet) { + int numberOfFrames(const MSEEDEncoderPacket &packet) const { return (packet.datalen >> 6); } private: - MSEEDFormat *format; - int frame_count; - int bp; - int fp; - int32_t last_s; - int spw; - int32_t last_sample; - int32_t buf[8]; - u_int32_t nibble_word; - MSEEDEncoderPacket current_packet; + MSEEDFormat *_format; + int _frameCount; + int _bp; + int _fp; + int32_t _last_s; + int _spw; + int32_t _lastSample; + int32_t _buf[8]; + u_int32_t _nibbleWord; + MSEEDEncoderPacket _currentPacket; }; diff --git a/libs/gempa/caps/mseed/steim2.ipp b/libs/gempa/caps/mseed/steim2.ipp index 44189cd..b685d11 100644 --- a/libs/gempa/caps/mseed/steim2.ipp +++ b/libs/gempa/caps/mseed/steim2.ipp @@ -32,163 +32,174 @@ namespace CAPS { template Steim2Encoder::~Steim2Encoder() { - if ( format != NULL ) delete format; + if ( _format ) { + delete _format; + } } -template void Steim2Encoder::update_spw(int bp) { - assert(bp < 7); +template void Steim2Encoder::updateSpw(int bp) { + assert(_bp < 7); - if(buf[bp] < -536870912) { + if ( _buf[_bp] < -536870912 ) { CAPS_WARNING("%s.%s.%s.%s: value %d is too large for Steim2 encoding", - format->networkCode.c_str(), format->stationCode.c_str(), - format->locationCode.c_str(), format->channelCode.c_str(), - buf[bp]); - buf[bp] = -536870912; - spw = 1; + _format->networkCode.c_str(), _format->stationCode.c_str(), + _format->locationCode.c_str(), _format->channelCode.c_str(), + _buf[_bp]); + _buf[_bp] = -536870912; + _spw = 1; return; } - if(buf[bp] > 536870911) { + if ( _buf[_bp] > 536870911 ) { CAPS_WARNING("%s.%s.%s.%s: value %d is too large for Steim2 encoding", - format->networkCode.c_str(), format->stationCode.c_str(), - format->locationCode.c_str(), format->channelCode.c_str(), - buf[bp]); - buf[bp] = 536870911; - spw = 1; + _format->networkCode.c_str(), _format->stationCode.c_str(), + _format->locationCode.c_str(), _format->channelCode.c_str(), + _buf[_bp]); + _buf[_bp] = 536870911; + _spw = 1; return; } int spw1 = 7; - if(buf[bp] < -16384 || buf[bp] > 16383) spw1 = 1; - else if(buf[bp] < -512 || buf[bp] > 511) spw1 = 2; - else if(buf[bp] < -128 || buf[bp] > 127) spw1 = 3; - else if(buf[bp] < -32 || buf[bp] > 31) spw1 = 4; - else if(buf[bp] < -16 || buf[bp] > 15) spw1 = 5; - else if(buf[bp] < -8 || buf[bp] > 7) spw1 = 6; - if(spw1 < spw) spw = spw1; + if ( _buf[_bp] < -16384 || _buf[_bp] > 16383 ) spw1 = 1; + else if ( _buf[_bp] < -512 || _buf[_bp] > 511 ) spw1 = 2; + else if ( _buf[_bp] < -128 || _buf[_bp] > 127 ) spw1 = 3; + else if ( _buf[_bp] < -32 || _buf[_bp] > 31 ) spw1 = 4; + else if ( _buf[_bp] < -16 || _buf[_bp] > 15 ) spw1 = 5; + else if ( _buf[_bp] < -8 || _buf[_bp] > 7 ) spw1 = 6; + if ( spw1 < _spw ) _spw = spw1; } template void Steim2Encoder::store(int32_t value) { - assert(bp < 7); - buf[bp] = value - last_sample; - last_sample = value; - update_spw(bp); - ++bp; + assert(_bp < 7); + _buf[_bp] = value - _lastSample; + _lastSample = value; + updateSpw(_bp); + ++_bp; } -template void Steim2Encoder::init_packet() { +template void Steim2Encoder::initPacket() { int i; - int32_t begin_sample = last_sample; + int32_t begin_sample = _lastSample; - for(i = 1; i < bp; ++i) { - begin_sample -= buf[i]; + for ( i = 1; i < _bp; ++i ) { + begin_sample -= _buf[i]; } reset(); - current_packet.data[0].sample_word[0] = htonl(begin_sample); - frame_count = 0; - nibble_word = 0; - fp = 2; + _currentPacket.data[0].sampleWord[0] = htonl(begin_sample); + _frameCount = 0; + _nibbleWord = 0; + _fp = 2; } -template void Steim2Encoder::finish_packet() { +template void Steim2Encoder::finishPacket() { int i; - int32_t end_sample = last_sample; + int32_t endSample = _lastSample; - for(i = 0; i < bp; ++i) { - end_sample -= buf[i]; + for ( i = 0; i < _bp; ++i ) { + endSample -= _buf[i]; } - current_packet.data[0].sample_word[1] = htonl(end_sample); + _currentPacket.data[0].sampleWord[1] = htonl(endSample); } -template void Steim2Encoder::update_packet() { +template void Steim2Encoder::updatePacket() { unsigned int nibble = 0; - u_int32_t sample_word = 0; + u_int32_t sampleWord = 0; - assert(bp < 8); + assert(_bp < 8); - int used = bp; + int used = _bp; - while(used > spw) { + while ( used > _spw ) { --used; - spw = 7; - for(int i = 0; i < used; ++i) update_spw(i); + _spw = 7; + + for ( int i = 0; i < used; ++i ) { + updateSpw(i); + } } - spw = used; + _spw = used; - switch(spw) { + switch ( _spw ) { case 7: nibble = 3; - sample_word = (2U << 30) | ((buf[0] & 0xf) << 24) | - ((buf[1] & 0xf) << 20) | ((buf[2] & 0xf) << 16) | - ((buf[3] & 0xf) << 12) | ((buf[4] & 0xf) << 8) | - ((buf[5] & 0xf) << 4) | (buf[6] & 0xf); + sampleWord = (2U << 30) | ((_buf[0] & 0xf) << 24) | + ((_buf[1] & 0xf) << 20) | ((_buf[2] & 0xf) << 16) | + ((_buf[3] & 0xf) << 12) | ((_buf[4] & 0xf) << 8) | + ((_buf[5] & 0xf) << 4) | (_buf[6] & 0xf); break; case 6: nibble = 3; - sample_word = (1U << 30) | ((buf[0] & 0x1f) << 25) | - ((buf[1] & 0x1f) << 20) | ((buf[2] & 0x1f) << 15) | - ((buf[3] & 0x1f) << 10) | ((buf[4] & 0x1f) << 5) | - (buf[5] & 0x1f); + sampleWord = (1U << 30) | ((_buf[0] & 0x1f) << 25) | + ((_buf[1] & 0x1f) << 20) | ((_buf[2] & 0x1f) << 15) | + ((_buf[3] & 0x1f) << 10) | ((_buf[4] & 0x1f) << 5) | + (_buf[5] & 0x1f); break; case 5: nibble = 3; - sample_word = ((buf[0] & 0x3f) << 24) | ((buf[1] & 0x3f) << 18) | - ((buf[2] & 0x3f) << 12) | ((buf[3] & 0x3f) << 6) | - (buf[4] & 0x3f); + sampleWord = ((_buf[0] & 0x3f) << 24) | ((_buf[1] & 0x3f) << 18) | + ((_buf[2] & 0x3f) << 12) | ((_buf[3] & 0x3f) << 6) | + (_buf[4] & 0x3f); break; case 4: nibble = 1; - sample_word = ((buf[0] & 0xff) << 24) | ((buf[1] & 0xff) << 16) | - ((buf[2] & 0xff) << 8) | (buf[3] & 0xff); + sampleWord = ((_buf[0] & 0xff) << 24) | ((_buf[1] & 0xff) << 16) | + ((_buf[2] & 0xff) << 8) | (_buf[3] & 0xff); break; case 3: nibble = 2; - sample_word = (3U << 30) | ((buf[0] & 0x3ff) << 20) | - ((buf[1] & 0x3ff) << 10) | (buf[2] & 0x3ff); + sampleWord = (3U << 30) | ((_buf[0] & 0x3ff) << 20) | + ((_buf[1] & 0x3ff) << 10) | (_buf[2] & 0x3ff); break; case 2: nibble = 2; - sample_word = (2U << 30) | ((buf[0] & 0x7fff) << 15) | - (buf[1] & 0x7fff); + sampleWord = (2U << 30) | ((_buf[0] & 0x7fff) << 15) | + (_buf[1] & 0x7fff); break; case 1: nibble = 2; - sample_word = (1U << 30) | (buf[0] & 0x3fffffff); + sampleWord = (1U << 30) | (_buf[0] & 0x3fffffff); break; default: assert(0); break; } - nibble_word |= (nibble << (30 - ((fp + 1) << 1))); + _nibbleWord |= (nibble << (30 - ((_fp + 1) << 1))); - spw = 7; - for(int i = 0; i < bp - used; ++i) { - buf[i] = buf[i + used]; - update_spw(i); + _spw = 7; + for ( int i = 0; i < _bp - used; ++i ) { + _buf[i] = _buf[i + used]; + updateSpw(i); } - bp -= used; + _bp -= used; _sampleCount += used; - current_packet.data[frame_count].nibble_word = htonl(nibble_word); - current_packet.data[frame_count].sample_word[fp] = htonl(sample_word); - if(++fp < 15) return; + _currentPacket.data[_frameCount].nibbleWord = htonl(_nibbleWord); + _currentPacket.data[_frameCount].sampleWord[_fp] = htonl(sampleWord); + + if ( ++_fp < 15 ) { + return; + } + + _nibbleWord = 0; + _fp = 0; + ++_frameCount; - nibble_word = 0; - fp = 0; - ++frame_count; return; } -template void Steim2Encoder::queue_packet(MSEEDEncoderPacket &pckt) { - format->updateBuffer(pckt.record, _sampleCount, frame_count + (fp > 0)); +template void Steim2Encoder::queuePacket(MSEEDEncoderPacket &pckt) { + _format->updateBuffer(pckt.record, _sampleCount, _frameCount + (_fp > 0)); - Packet *packet = new Packet(DataRecordPtr(pckt.record), format->networkCode, format->stationCode, - format->locationCode, format->channelCode); + Packet *packet = new Packet(DataRecordPtr(pckt.record), _format->networkCode, + _format->stationCode, + _format->locationCode, + _format->channelCode); _packetQueue.push_back(PacketPtr(packet)); pckt.reset(); reset(); @@ -200,37 +211,37 @@ template void Steim2Encoder::push(void *value) { store(sample_val); _clk.tick(); - while ( bp >= spw ) { - if( !current_packet.valid() ) { - current_packet = get_packet(); - init_packet(); + while ( _bp >= _spw ) { + if ( !_currentPacket.valid() ) { + _currentPacket = getPacket(); + initPacket(); } - update_packet(); - if ( frame_count == number_of_frames(current_packet) ) { - finish_packet(); - queue_packet(current_packet); + updatePacket(); + if ( _frameCount == numberOfFrames(_currentPacket) ) { + finishPacket(); + queuePacket(_currentPacket); } } } template void Steim2Encoder::flush() { - while ( bp ) { - if ( !current_packet.valid() ) { - current_packet = get_packet(); - init_packet(); + while ( _bp ) { + if ( !_currentPacket.valid() ) { + _currentPacket = getPacket(); + initPacket(); } - update_packet(); - if( frame_count == number_of_frames(current_packet) ) { - finish_packet(); - queue_packet(current_packet); + updatePacket(); + if ( _frameCount == numberOfFrames(_currentPacket) ) { + finishPacket(); + queuePacket(_currentPacket); } } - if ( current_packet.valid() ) { - finish_packet(); - queue_packet(current_packet); + if ( _currentPacket.valid() ) { + finishPacket(); + queuePacket(_currentPacket); } } diff --git a/libs/gempa/caps/mseed/uncompressed.h b/libs/gempa/caps/mseed/uncompressed.h index f6f91a7..bcd7491 100644 --- a/libs/gempa/caps/mseed/uncompressed.h +++ b/libs/gempa/caps/mseed/uncompressed.h @@ -12,28 +12,29 @@ * from gempa GmbH. * ***************************************************************************/ + #ifndef CAPS_MSEED_UNCOMPRESSED_H #define CAPS_MSEED_UNCOMPRESSED_H + #include "encoder.h" #include "mseed.h" #include -#include -#include namespace Gempa { namespace CAPS { + template class UncompressedMSEED : public Encoder { MSEEDEncoderPacket get_packet() { - return _format->get_packet(_clk.get_time(-_bp), - _clk.correction(), _timingQuality); + return _format->getPacket(_clk.getTime(-_bp), + _clk.correction(), _timingQuality); } - void queue_packet(MSEEDEncoderPacket &pckt) { + void queuePacket(MSEEDEncoderPacket &pckt) { _format->updateBuffer(pckt.record, _sampleCount, 1); Packet *packet = new Packet(DataRecordPtr(pckt.record), _format->networkCode, _format->stationCode, @@ -51,7 +52,7 @@ template class UncompressedMSEED : public Encoder { virtual ~UncompressedMSEED() { if ( _format ) delete _format; } virtual void flush() { if ( _current_packet.valid() ) { - queue_packet(_current_packet); + queuePacket(_current_packet); } } @@ -72,13 +73,15 @@ template class UncompressedMSEED : public Encoder { virtual int type() const { return _format->packType; } private: - MSEEDFormat *_format; - MSEEDEncoderPacket _current_packet; - int _bp; + MSEEDFormat *_format; + MSEEDEncoderPacket _current_packet; + int _bp; }; + } } + #endif // __STEIM1_H__ diff --git a/libs/gempa/caps/mseedpacket.cpp b/libs/gempa/caps/mseedpacket.cpp index 0fe5351..571553d 100644 --- a/libs/gempa/caps/mseedpacket.cpp +++ b/libs/gempa/caps/mseedpacket.cpp @@ -54,7 +54,6 @@ bool MSEEDDataRecord::readMetaData(std::streambuf &buf, int size, Header &header, Time &startTime, Time &endTime) { -#if 1 // Set this to 1 to enable no-malloc fast MSeed meta parser fsdh_s head; if ( size <= 0 ) { @@ -239,22 +238,7 @@ bool MSEEDDataRecord::readMetaData(std::streambuf &buf, int size, endTime += TimeSpan((hptime_t)hptime/HPTMODULUS,(hptime_t)hptime%HPTMODULUS); } - timeToTimestamp(_header.samplingTime, startTime); -#else - std::vector data(size); - size_t read = buf.sgetn(&data[0], data.size()); - if ( read != data.size() ) { - CAPS_WARNING("read metadata: input buffer underflow: only %d/%d bytes read", - (int)read, (int)data.size()); - return; - } - - unpackHeader(&data[0], data.size()); - - header = _header; - startTime = _startTime; - endTime = _endTime; -#endif + timeToTimestamp(header.samplingTime, startTime); return true; } @@ -328,93 +312,6 @@ DataRecord::ReadStatus MSEEDDataRecord::get(std::streambuf &buf, int size, } return RS_Complete; - - /* - // Only unpack the header structure - int state = msr_unpack(&_data[0], _data.size(), &ms_rec, 0, 0); - if ( state != MS_NOERROR ) { - switch ( state ) { - case MS_GENERROR: - CAPS_WARNING("get: generic libmseed error"); - break; - case MS_NOTSEED: - CAPS_WARNING("get: input data is not seed"); - break; - case MS_WRONGLENGTH: - CAPS_WARNING("get: length of data read was not correct"); - break; - case MS_OUTOFRANGE: - CAPS_WARNING("get: SEED record length out of range"); - break; - case MS_UNKNOWNFORMAT: - CAPS_WARNING("get: unknown data encoding format"); - break; - case MS_STBADCOMPFLAG: - CAPS_WARNING("get: invalid Steim compression flag(s)"); - break; - } - if ( ms_rec != NULL ) - msr_free(&ms_rec); - return RS_Error; - } - - hptime_t hptime = msr_starttime(ms_rec); - _startTime = Time((hptime_t)hptime/HPTMODULUS,(hptime_t)hptime%HPTMODULUS); - _endTime = _startTime; - - if ( ms_rec->samprate > 0.0 && ms_rec->samplecnt > 0 ) { - hptime = (hptime_t)(((double)(ms_rec->samplecnt) / ms_rec->samprate * HPTMODULUS) + 0.5); - _endTime += TimeSpan((hptime_t)hptime/HPTMODULUS,(hptime_t)hptime%HPTMODULUS); - } - - _header.dataType = DT_Unknown; - timeToTimestamp(_header.samplingTime, _startTime); - - if ( ms_rec->fsdh->samprate_fact > 0 ) { - _header.samplingFrequencyNumerator = ms_rec->fsdh->samprate_fact; - _header.samplingFrequencyDenominator = 1; - } - else { - _header.samplingFrequencyNumerator = 1; - _header.samplingFrequencyDenominator = -ms_rec->fsdh->samprate_fact; - } - - if ( ms_rec->fsdh->samprate_mult > 0 ) - _header.samplingFrequencyNumerator *= ms_rec->fsdh->samprate_mult; - else - _header.samplingFrequencyDenominator *= -ms_rec->fsdh->samprate_mult; - - switch ( ms_rec->sampletype ) { - case 'a': - _header.dataType = DT_INT8; - break; - case 'i': - _header.dataType = DT_INT32; - break; - case 'f': - _header.dataType = DT_FLOAT; - break; - case 'd': - _header.dataType = DT_DOUBLE; - break; - default: - _header.dataType = DT_Unknown; - break; - } - - msr_free(&ms_rec); - - if ( start.valid() || end.valid() ) { - // Out of scope? - if ( end.valid() && (end <= _startTime) ) - return RS_AfterTimeWindow; - - if ( start.valid() && (start >= _endTime) ) - return RS_BeforeTimeWindow; - } - - return RS_Complete; - */ } diff --git a/libs/gempa/caps/plugin.cpp b/libs/gempa/caps/plugin.cpp index 6149a91..518e7b1 100644 --- a/libs/gempa/caps/plugin.cpp +++ b/libs/gempa/caps/plugin.cpp @@ -13,6 +13,7 @@ ***************************************************************************/ +#include #include #include #include @@ -43,6 +44,8 @@ #include #endif +#include + #include #include #include @@ -119,6 +122,8 @@ namespace CAPS { namespace { +#define HELLO_REQUEST "HELLO\n" + #if !defined(CAPS_FEATURES_JOURNAL) || CAPS_FEATURES_JOURNAL bool createPath(const string &dir) { try { @@ -141,6 +146,49 @@ bool createPath(const string &dir) { // } //} +template void dumpSamples(RawDataRecord *rec, size_t sampleCount) { + const vector *data = reinterpret_cast* >(rec->data()); + for ( size_t i = 0; i < sampleCount; ++i ) { + cout << data->at(i) << endl; + } +} + +void dumpSList(Packet *packet) { + RawDataRecord *rec = static_cast(packet->record.get()); + string id = packet->streamID; + boost::replace_all(id, ".", "_"); + + string dataType = packet->record->formatName(); + boost::replace_all(dataType, "RAW/", ""); + + DataType dt = rec->header()->dataType; + size_t sampleCount = rec->data()->size() / dataTypeSize(dt); + + cout << "TIMESERIES " << id << "_R, " + << sampleCount << " samples, " + << static_cast(rec->header()->samplingFrequencyNumerator) / rec->header()->samplingFrequencyDenominator << " sps, " + << packet->record->startTime().iso() << " SLIST, " + << dataType << ", " << packet->uom << endl; + if ( dt == DT_INT8 ) { + dumpSamples(rec, sampleCount); + } + else if ( dt == DT_INT16 ) { + dumpSamples(rec, sampleCount); + } + else if ( dt == DT_INT32 ) { + dumpSamples(rec, sampleCount); + } + else if ( dt == DT_INT64 ) { + dumpSamples(rec, sampleCount); + } + else if ( dt == DT_FLOAT ) { + dumpSamples(rec, sampleCount); + } + else if ( dt == DT_DOUBLE ) { + dumpSamples(rec, sampleCount); + } +} + template void fillPacket(Packet *packet, uint16_t version) { PacketDataHeader header; header.packetType = packet->record->packetType(); @@ -190,9 +238,9 @@ void insertPacket(Plugin::BackfillingBuffer &buf, PacketPtr packet) { for ( it = buf.begin(); it != buf.end(); ++it, ++pos ) { if ( (*it)->record->endTime() > packet->record->endTime() ) { buf.insert(it, packet); - CAPS_DEBUG("Backfilling buffer: packet inserted at pos: %lu, new " - "size: %lu, time window: %s~%s", (long unsigned) pos, - (long unsigned) buf.size(), + CAPS_DEBUG("Backfilling buffer: packet inserted at pos: %zu, new " + "size: %zu, time window: %s~%s", + pos, buf.size(), buf.front()->record->startTime().iso().c_str(), buf.back()->record->endTime().iso().c_str()); //dump(buf); @@ -202,8 +250,8 @@ void insertPacket(Plugin::BackfillingBuffer &buf, PacketPtr packet) { buf.push_back(packet); - CAPS_DEBUG("Backfilling buffer: packet appended, new size: %lu, time window: %s~%s", - (long unsigned) buf.size(), + CAPS_DEBUG("Backfilling buffer: packet appended, new size: %zu, time window: %s~%s", + buf.size(), buf.front()->record->startTime().iso().c_str(), buf.back()->record->endTime().iso().c_str()); //dump(buf); @@ -234,14 +282,14 @@ Plugin::Plugin(const string &name, const string &options, , _description(description) , _bufferSize(1 << 14) , _bytesBuffered(0) -, _port(18003) , _sendTimeout(60) , _isExitRequested(false) #if !defined(CAPS_FEATURES_BACKFILLING) || CAPS_FEATURES_BACKFILLING , _backfillingBufferSize(0) #endif { - + _url.host = "localhost"; + _url.port = 18003; #if !defined(CAPS_FEATURES_JOURNAL) || CAPS_FEATURES_JOURNAL _lastWrite = Time::GMT(); _journalDirty = false; @@ -256,6 +304,7 @@ Plugin::Plugin(const string &name, const string &options, #if !defined(CAPS_FEATURES_SSL) || CAPS_FEATURES_SSL _useSSL = false; #endif + _dumpPackets = false; } @@ -286,7 +335,7 @@ void Plugin::close() { flushEncoders(); sendBye(); - CAPS_INFO("Closing connection to CAPS at %s:%d", _host.c_str(), _port); + CAPS_INFO("Closing connection to CAPS at %s:%d", _url.host.c_str(), _url.port); while ( !_packetBuffer.empty() && readResponse(_lastAckTimeout) ); @@ -295,7 +344,7 @@ void Plugin::close() { #endif disconnect(); - CAPS_INFO("Closed connection to CAPS at %s:%d", _host.c_str(), _port); + CAPS_INFO("Closed connection to CAPS at %s:%d", _url.host.c_str(), _url.port); _packetBuffer.clear(); _wasConnected = false; @@ -313,16 +362,34 @@ bool Plugin::connect() { #endif CAPS_INFO("Attempting to connect to CAPS at %s:%d", - _host.c_str(), _port); - if ( _socket->connect(_host, _port) != Socket::Success ) { - CAPS_ERROR("Connection failed to CAPS at %s:%d", _host.c_str(), _port); + _url.host.c_str(), _url.port); + if ( _socket->connect(_url.host, _url.port) != Socket::Success ) { + CAPS_ERROR("Connection failed to CAPS at %s:%d", _url.host.c_str(), _url.port); return false; } // Do handshake - if ( !_user.empty() && !_password.empty() ) { - string auth = "AUTH "+ _user + " " + _password + "\n"; - _socket->write(auth.c_str(), auth.length()); + + int apiVersion = 0; + if ( !getAPIVersion(apiVersion) ) { + return false; + } + + CAPS_INFO("Found CAPS API version %d", apiVersion); + if ( apiVersion >= 5 ) { + if ( !_agent.empty() ) { + _socket->write("AGENT ", 6); + _socket->write(_agent.data(), _agent.size()); + _socket->write("\n", 1); + } + } + + if ( !_url.user.empty() && !_url.password.empty() ) { + _socket->write("AUTH ", 5); + _socket->write(_url.user.data(), _url.user.size()); + _socket->write(" ", 1); + _socket->write(_url.password.data(), _url.password.size()); + _socket->write("\n", 1); } _socket->setNonBlocking(true); @@ -333,7 +400,7 @@ bool Plugin::connect() { FD_SET(_socket->fd(), &_readFDs); FD_SET(_socket->fd(), &_writeFDs); - CAPS_INFO("Connected to CAPS at %s:%d", _host.c_str(), _port); + CAPS_INFO("Connected to CAPS at %s:%d", _url.host.c_str(), _url.port); _responseBuf[0] = '\0'; _responseBufIdx = 0; @@ -354,7 +421,7 @@ bool Plugin::connect() { void Plugin::disconnect() { if ( _socket && _socket->isValid() ) { - CAPS_INFO("Disconnect from %s:%d", _host.c_str(), _port); + CAPS_INFO("Disconnect from %s:%d", _url.host.c_str(), _url.port); _socket->shutdown(); _socket->close(); @@ -374,7 +441,7 @@ bool Plugin::readResponse(unsigned int timeout) { bool gotResponse = false; - #define bufN 512 + const int bufN = 512; char buf[bufN]; int res; @@ -419,7 +486,7 @@ bool Plugin::readResponse(unsigned int timeout) { // Read confirmed packets from response int count = atoi(_responseBuf+3); - CAPS_DEBUG("Acknowledged %d packets, %d in queue", count, (int)_packetBuffer.size()); + CAPS_DEBUG("Acknowledged %d packets, %zu in queue", count, _packetBuffer.size()); // Update packet buffer for ( int i = 0; i < count; ++i ) { if ( _packetBuffer.empty() ) { @@ -446,8 +513,12 @@ bool Plugin::readResponse(unsigned int timeout) { } } - CAPS_DEBUG("Packet buffer state: %d packets, %d bytes", - (int)_packetBuffer.size(), (int)_bytesBuffered); + CAPS_DEBUG("Packet buffer state: %zu packets, %zu bytes", + _packetBuffer.size(), _bytesBuffered); + } + else if ( (strncasecmp(_responseBuf, "ERROR ", 6) == 0) && (_responseBufIdx > 6) ) { + CAPS_ERROR("%s", _responseBuf + 6); + return false; } _responseBuf[0] = '\0'; @@ -529,7 +600,7 @@ bool Plugin::readJournal(istream &is) { #endif bool Plugin::flush() { - CAPS_INFO("Flushing %d queued packets", (int)_packetBuffer.size()); + CAPS_INFO("Flushing %zu queued packets", _packetBuffer.size()); PacketBuffer::iterator it = _packetBuffer.begin(); while ( it != _packetBuffer.end() && !_isExitRequested ) { @@ -567,7 +638,7 @@ bool Plugin::flush() { } void Plugin::flushEncoders() { - CAPS_INFO("Flushing %d encoders", (int)_encoderItems.size()); + CAPS_INFO("Flushing %zu encoders", _encoderItems.size()); EncoderItems::iterator it = _encoderItems.begin(); while ( it != _encoderItems.end() ) { Encoder *encoder = it->second.encoder.get(); @@ -598,7 +669,7 @@ Plugin::Status Plugin::push(const string &net, const string &sta, rec->setStartTime(stime); rec->setSamplingFrequency(numerator, denominator); rec->setDataType(dt); - rec->setBuffer((char*)data, dtSize * count); + rec->setBuffer(static_cast(data), dtSize * count); return push(net, sta, loc, cha, DataRecordPtr(rec), uom, timingQuality); } @@ -638,7 +709,7 @@ void Plugin::tryFlushBackfillingBuffer(StreamState &state) { PacketPtr &ref_pkt = state.backfillingBuffer.front(); TimeSpan gap = ref_pkt->record->startTime() - state.lastCommitEndTime; - int64_t dt_us = (int64_t)gap.seconds()*1000000+gap.microseconds(); + int64_t dt_us = static_cast(gap.seconds()) * 1000000 + gap.microseconds(); // A gap larger than one sample? if ( dt_us >= ref_pkt->dt_us ) break; @@ -652,15 +723,14 @@ void Plugin::tryFlushBackfillingBuffer(StreamState &state) { if ( flushed > 0 ) { if ( state.backfillingBuffer.size() > 0 ) { - CAPS_DEBUG("backfilling buffer: %lu pakets flushed, new size: %lu, time window: %s~%s", - (long unsigned) flushed, - (long unsigned) state.backfillingBuffer.size(), + CAPS_DEBUG("backfilling buffer: %zu pakets flushed, new size: %zu, time window: %s~%s", + flushed, state.backfillingBuffer.size(), state.backfillingBuffer.front()->record->startTime().iso().c_str(), state.backfillingBuffer.back()->record->endTime().iso().c_str()); } else { - CAPS_DEBUG("backfilling buffer: %lu pakets flushed, new size: 0", - (long unsigned) flushed); + CAPS_DEBUG("backfilling buffer: %zu pakets flushed, new size: 0", + flushed); } } } @@ -684,15 +754,14 @@ void Plugin::trimBackfillingBuffer(StreamState &state) { if ( trimmed > 0 ) { if ( state.backfillingBuffer.size() > 0 ) { - CAPS_DEBUG("backfilling buffer: %lu pakets trimmed, new size: %lu, time window: %s~%s", - (long unsigned) trimmed, - (long unsigned) state.backfillingBuffer.size(), + CAPS_DEBUG("backfilling buffer: %zu pakets trimmed, new size: %zu, time window: %s~%s", + trimmed, state.backfillingBuffer.size(), state.backfillingBuffer.front()->record->startTime().iso().c_str(), state.backfillingBuffer.back()->record->endTime().iso().c_str()); } else { - CAPS_DEBUG("backfilling buffer: %lu pakets trimmed, new size: 0", - (long unsigned) trimmed); + CAPS_DEBUG("backfilling buffer: %zu pakets trimmed, new size: 0", + trimmed); } } } @@ -792,6 +861,12 @@ void Plugin::serializePacket(Packet *packet) { } bool Plugin::commitPacket(PacketPtr packet) { + if ( _dumpPackets ) { + serializePacket(packet.get()); + dumpPacket(packet.get()); + return true; + } + // Initial connect if ( !_wasConnected && !_socket ) { while ( !connect() && !_isExitRequested ) { @@ -803,12 +878,16 @@ bool Plugin::commitPacket(PacketPtr packet) { } if ( _bytesBuffered >= _bufferSize ) { - CAPS_DEBUG("Packet buffer is full (%ld/%ld bytes), " + CAPS_DEBUG("Packet buffer is full (%zu/%zu bytes), " "waiting for server ack messages", _bytesBuffered, _bufferSize); while ( _bytesBuffered >= _bufferSize ) { if ( !readResponse(_ackTimeout) ) { + CAPS_WARNING("Packet buffer was full (%zu/%zu bytes), " + "did not receive ack within %d seconds", + _bytesBuffered, _bufferSize, + _ackTimeout); disconnect(); while ( !_isExitRequested && !_socket->isValid() ) { wait(); @@ -821,7 +900,7 @@ bool Plugin::commitPacket(PacketPtr packet) { } } - CAPS_DEBUG("%ld/%ld bytes buffered after force wait", + CAPS_DEBUG("%zu/%zu bytes buffered after force wait", _bytesBuffered, _bufferSize); if ( _bytesBuffered >= _bufferSize ) @@ -835,8 +914,8 @@ bool Plugin::commitPacket(PacketPtr packet) { // Serialize data record serializePacket(packet.get()); - CAPS_DEBUG("+ buffer state: %d packets, %d bytes", - (int)_packetBuffer.size(), (int)_bytesBuffered); + CAPS_DEBUG("+ buffer state: %zu packets, %zu bytes", + _packetBuffer.size(), _bytesBuffered); while ( !sendPacket(packet.get() ) ) { CAPS_ERROR("Sending failed: %s", _isExitRequested ? "abort" : "reconnect"); @@ -887,11 +966,11 @@ Encoder* Plugin::getEncoder(PacketPtr packet) { */ const SPClock &clk = item->encoder->clk(); bool needsFlush = false; - if( clk.freqn != header->samplingFrequencyNumerator || + if ( clk.freqn != header->samplingFrequencyNumerator || clk.freqd != header->samplingFrequencyDenominator ) { needsFlush = true; } - else if ( record->startTime() != clk.get_time(0) ) { + else if ( record->startTime() != clk.getTime(0) ) { needsFlush = true; } else if ( item->dataType != header->dataType ) { @@ -970,7 +1049,7 @@ void Plugin::sendBye() { if ( _socket == NULL ) return; PacketDataHeader header; - memset((char*)&header, 0, header.dataSize()); + memset(reinterpret_cast(&header), 0, header.dataSize()); _socket->setNonBlocking(false); send((char*)&header, header.dataSize(), _sendTimeout); @@ -1077,8 +1156,9 @@ void Plugin::enableLogging() { } bool Plugin::send(char *data, int len, int timeout) { - if ( !_socket->isValid() ) + if ( !_socket->isValid() ) { return false; + } struct timeval tv; tv.tv_sec = timeout; @@ -1116,5 +1196,94 @@ bool Plugin::send(char *data, int len, int timeout) { return false; } +bool Plugin::setAddress(const string &addr, uint16_t defaultPort) { + if ( !_url.parse(addr, defaultPort) ) { + CAPS_ERROR("Failed to set address: %s", + _url.errorString.c_str()); + return false; + } + +#if !defined(CAPS_FEATURES_SSL) || CAPS_FEATURES_SSL + _useSSL = boost::iequals(_url.protocol, "capss"); +#endif + + return true; +} + +void Plugin::dumpPacket(Packet *packet) { + if ( packet->record->packetType() == RawDataPacket ) { + dumpSList(packet); + } + else if ( packet->record->packetType() == MSEEDPacket ) { + MSEEDDataRecord *rec = static_cast(packet->record.get()); + cout.write(rec->data()->data(), + static_cast(rec->data()->size())); + } + else { + cout << "Could not dump packet: Unsupported packet type '" + << packet->record->packetType() << "'"; + } +} + +void Plugin::dumpPackets(bool enable) { + _dumpPackets = enable; +} + +void Plugin::setAgent(const std::string &agent) { + _agent = agent; +} + +bool Plugin::getAPIVersion(int &version) { + version = 0; + + int bytesSent = _socket->send(HELLO_REQUEST); + if ( bytesSent != strlen(HELLO_REQUEST) ) { + CAPS_ERROR("Could not get CAPS API version: %s", + strerror(errno)); + return false; + } + + int32_t msgLength = 0; + + socketbuf buf(_socket.get()); + streamsize bytesRead = buf.sgetn(reinterpret_cast(&msgLength), + sizeof(int32_t)); + if ( bytesRead != sizeof(int32_t) ) { + CAPS_ERROR("Could not get CAPS API version: Expected message length in " + "server response: %s", strerror(errno)); + return false; + } + + msgLength = Endianess::Converter::FromLittleEndian(msgLength); + + // Check if the hello response comes from a CAPS server with + // API version < 5 + constexpr int32_t OKTag = 0x30204b4f; + if ( msgLength == OKTag ) { + return true; + } + + buf.set_read_limit(msgLength); + + bool ret = true; + + iostream is(&buf); + string line; + while ( getline(is, line) ) { + size_t pos = line.find("API="); + if ( pos == string::npos ) { + continue; + } + + string apiStr = line.substr(4); + if ( !str2int(version, apiStr.c_str()) ) { + CAPS_ERROR("Invalid CAPS API version: Expected number"); + ret = false; + } + } + + return ret; +} + } } diff --git a/libs/gempa/caps/plugin.h b/libs/gempa/caps/plugin.h index 5a36a28..5a8dfc2 100644 --- a/libs/gempa/caps/plugin.h +++ b/libs/gempa/caps/plugin.h @@ -34,6 +34,7 @@ #include #include +#include #include #include @@ -70,8 +71,9 @@ class SC_GEMPA_CAPS_API Plugin { size_t maxBytesBuffered; }; - typedef std::vector Buffer; - typedef boost::shared_ptr BufferPtr; + typedef std::vector Buffer; + typedef boost::shared_ptr BufferPtr; + typedef std::deque PacketBuffer; #if !defined(CAPS_FEATURES_BACKFILLING) || CAPS_FEATURES_BACKFILLING typedef std::list BackfillingBuffer; @@ -139,11 +141,19 @@ class SC_GEMPA_CAPS_API Plugin { */ void setEncoderFactory(EncoderFactory *factory); - void setHost(const std::string &host) { _host = host; } - const std::string &host() const { return _host; } + /** + * @brief Parses connection parameters from address string. Format + * is [[caps|capss]://][user:pass@]host[:port] + * @param addr The address of the caps server as string + * @param defaultPort The default port used when the port is omitted + */ + bool setAddress(const std::string &addr, uint16_t defaultPort = 18003); + + void setHost(const std::string &host) { _url.host = host; } + const std::string &host() const { return _url.host; } - void setPort(unsigned short port) { _port = port; } - unsigned short port() const { return _port; } + void setPort(unsigned short port) { _url.port = port; } + unsigned short port() const { return _url.port; } void setBufferSize(size_t bufferSize) { _bufferSize = bufferSize; } size_t bufferSize() const { return _bufferSize; } @@ -159,8 +169,8 @@ class SC_GEMPA_CAPS_API Plugin { * @param password The password */ void setCredentials(const std::string &user, const std::string &password) { - _user = user; - _password = password; + _url.user = user; + _url.password = password; } /** @@ -232,12 +242,42 @@ class SC_GEMPA_CAPS_API Plugin { const std::string &data); #endif + void flushEncoders(); + + void dumpPackets(bool enable); + + /** + * @brief Returns the internal packet buffer that + * keeps packets until they have been acknowledged + * by CAPS + * @return The interal packet buffer + */ + const PacketBuffer &packetBuffer() const { + return _packetBuffer; + } + + /** + * @brief Sets the agent string. Allows the server to + * identify the application that sends data. + * @param agent The agent string + */ + void setAgent(const std::string &agent); + const char *version() { return LIB_CAPS_VERSION_NAME; } + protected: + /** + * @brief Sends HELLO request and parses API version + * from server response. If the server does not support + * the API feature the method sets the version to 0. + * @param version The CAPS API version, e.g., 5 + * @return True on success + */ + bool getAPIVersion(int &version); + private: - typedef std::deque PacketBuffer; typedef boost::shared_ptr EncoderPtr; struct EncoderItem { @@ -250,6 +290,7 @@ class SC_GEMPA_CAPS_API Plugin { private: bool connect(); void disconnect(); + void dumpPacket(Packet *packet); bool isConnected() const; Encoder* getEncoder(PacketPtr packet); bool readResponse(unsigned int sec = 0); @@ -265,7 +306,6 @@ class SC_GEMPA_CAPS_API Plugin { void tryFlushBackfillingBuffer(StreamState &state); void trimBackfillingBuffer(StreamState &state); bool flush(); - void flushEncoders(); bool send(char *data, int len, int timeout = 60); void wait(); @@ -279,8 +319,6 @@ class SC_GEMPA_CAPS_API Plugin { PacketBuffer _packetBuffer; bool _packetBufferDirty; size_t _bytesBuffered; - std::string _host; - unsigned short _port; char _responseBuf[512]; int _responseBufIdx; fd_set _readFDs; @@ -306,13 +344,15 @@ class SC_GEMPA_CAPS_API Plugin { PacketAckFunc _packetAckFunc; - std::string _user; - std::string _password; + Url _url; #if !defined(CAPS_FEATURES_SSL) || CAPS_FEATURES_SSL bool _useSSL; #endif Stats _stats; TimeSpan _maxFutureEndTime; + + bool _dumpPackets; + std::string _agent; }; typedef boost::shared_ptr PluginPtr; diff --git a/libs/gempa/caps/pluginapplication.cpp b/libs/gempa/caps/pluginapplication.cpp index 452430a..a0324f0 100644 --- a/libs/gempa/caps/pluginapplication.cpp +++ b/libs/gempa/caps/pluginapplication.cpp @@ -91,13 +91,9 @@ PluginApplication::PluginApplication(int argc, char **argv, const string &desc) _sendTimeout = 60; _logStatus = false; _statusFlushInterval = 10; - - _host = "localhost"; - _port = DEFAULT_PORT; - _strAddr = "localhost:" + sc::toString(DEFAULT_PORT); - SC_FS_DECLARE_PATH(path, "@ROOTDIR@/var/run/" + SCCoreApp->name() + "/journal"); + SC_FS_DECLARE_PATH(path, "@ROOTDIR@/var/run/" + SCCoreApp->name() + "/journal") _journalFile = path.string(); _mseedEnabled = false; @@ -105,6 +101,7 @@ PluginApplication::PluginApplication(int argc, char **argv, const string &desc) _mseedRecordLength = 9; _strMseedEncoding = "Steim2"; _maxFutureEndTime = 120; + _dumpPackets = false; // By default we disable the acquisition autostart because not all plugins // require this feature. It must be enabled explicitly if required. @@ -114,8 +111,16 @@ PluginApplication::PluginApplication(int argc, char **argv, const string &desc) void PluginApplication::createCommandLineDescription() { Seiscomp::Client::StreamApplication::createCommandLineDescription(); commandline().addGroup("Output"); - commandline().addOption("Output", "addr,a", "Data output address, format is [HOST:PORT]", &_strAddr); - commandline().addOption("Output", "buffer-size,b", "Size (bytes) of the packet buffer", &_bufferSize); + commandline().addOption("Output", "addr,a", + "Data output address\n" + "[[caps|capss]://][user:pass@]host[:port]", &_strAddr); + commandline().addOption("Output", "agent", + "Sets the agent string. Allows " + "the server to identify the " + "application that sends data.", + &_agent); + commandline().addOption("Output", "buffer-size,b", + "Size (bytes) of the packet buffer", &_bufferSize); commandline().addOption("Output", "backfilling", "Enable backfilling for out-of-order records. The backfilling buffer size is " "in seconds", &_backfillingBufferSize); @@ -132,6 +137,7 @@ void PluginApplication::createCommandLineDescription() { "the packet end time is greater than the current time plus this " "value the packet will be discarded. By default this value is set to 120 seconds.", &_maxFutureEndTime); + commandline().addOption("Output", "dump-packets", "Dump packets to stdout"); commandline().addGroup("Journal"); commandline().addOption("Journal", "journal,j", "File to store stream states. Use an empty string to disable this feature.", &_journalFile); @@ -192,12 +198,12 @@ bool PluginApplication::init() { Gempa::CAPS::SetLogHandler(Gempa::CAPS::LL_INFO, LogInfo); Gempa::CAPS::SetLogHandler(Gempa::CAPS::LL_DEBUG, LogDebug); - _plugin.setHost(_host); - _plugin.setPort(_port); _plugin.setBufferSize(_bufferSize); _plugin.setFlushInterval(_flushInterval); _plugin.setTimeouts(_ackTimeout, _lastAckTimeout, _sendTimeout); _plugin.setMaxFutureEndTime(_maxFutureEndTime); + _plugin.dumpPackets(_dumpPackets); + _plugin.setAgent(_agent); if ( _mseedEnabled ) { MSEEDEncoderFactory *factory = nullptr; @@ -211,7 +217,7 @@ bool PluginApplication::init() { factory = new Steim1EncoderFactory(); _plugin.setEncoderFactory(factory); } - if ( _mseedEncoding == Steim2 ) { + else if ( _mseedEncoding == Steim2 ) { SEISCOMP_INFO("Output stream encoding set to MiniSEED/Steim2"); factory = new Steim2EncoderFactory(); _plugin.setEncoderFactory(factory); @@ -260,20 +266,23 @@ bool PluginApplication::init() { bool PluginApplication::initConfiguration() { if ( !Seiscomp::Client::StreamApplication::initConfiguration() ) return false; - try { _host = configGetString("output.host"); } - catch ( ... ) { } + try { + _plugin.setHost(configGetString("output.host")); + } + catch ( ... ) { + } - try { _port = configGetInt("output.port"); } + try { + _plugin.setPort(configGetInt("output.port")); + } catch ( ... ) { } try { _sendTimeout = configGetInt("output.timeout"); } catch ( ... ) { } try { - string addr = configGetString("output.addr"); - if ( !splitAddress(_host, _port, addr, DEFAULT_PORT) ) { - SEISCOMP_ERROR("%s: Invalid CAPS address, format is [HOST:PORT]", - addr.c_str()); + string addr = configGetString("output.address"); + if ( !_plugin.setAddress(addr) ) { return false; } } @@ -307,6 +316,19 @@ bool PluginApplication::initConfiguration() { try { _backfillingBufferSize = configGetInt("output.backfillingBufferSize"); } catch ( ... ) { } + try { _maxFutureEndTime = configGetInt("output.maxFutureEndTime"); } + catch ( ... ) { } + + try { _agent = configGetString("output.agent"); } + catch ( ... ) { + if ( version() ) { + _agent = name() + string(" ") + version(); + } + else { + _agent = name(); + } + } + try { _journalFile = configGetString("journal.file"); } catch ( ... ) {} @@ -325,9 +347,6 @@ bool PluginApplication::initConfiguration() { try { _statusFlushInterval = configGetInt("statusLog.flush"); } catch ( ... ) {} - try { _maxFutureEndTime= configGetInt("output.maxFutureEndTime"); } - catch ( ... ) { } - return true; } @@ -342,6 +361,10 @@ bool PluginApplication::validateParameters() { _logStatus = true; } + if ( commandline().hasOption("dump-packets") ) { + _dumpPackets = true; + } + if ( commandline().hasOption("encoding") ) { if ( !fromString(_mseedEncoding, _strMseedEncoding)) return false; } @@ -353,9 +376,7 @@ bool PluginApplication::validateParameters() { } if ( commandline().hasOption("addr") ) { - if ( !splitAddress(_host, _port, _strAddr, DEFAULT_PORT) ) { - SEISCOMP_ERROR("%s: Invalid CAPS address, format is [HOST:PORT]", - _strAddr.c_str()); + if ( !_plugin.setAddress(_strAddr, DEFAULT_PORT) ) { return false; } } diff --git a/libs/gempa/caps/pluginapplication.h b/libs/gempa/caps/pluginapplication.h index ba5a46d..83ff19d 100644 --- a/libs/gempa/caps/pluginapplication.h +++ b/libs/gempa/caps/pluginapplication.h @@ -83,8 +83,6 @@ class SC_GEMPA_CAPS_API PluginApplication : public Seiscomp::Client::StreamAppli protected: Plugin _plugin; - std::string _host; - ushort _port; std::string _strAddr; size_t _bufferSize; size_t _backfillingBufferSize; @@ -105,6 +103,8 @@ class SC_GEMPA_CAPS_API PluginApplication : public Seiscomp::Client::StreamAppli FileRotator _statusFile; bool _logStatus; uint _statusFlushInterval; + bool _dumpPackets; + std::string _agent; }; } diff --git a/libs/gempa/caps/rawpacket.cpp b/libs/gempa/caps/rawpacket.cpp index 2855add..a326126 100644 --- a/libs/gempa/caps/rawpacket.cpp +++ b/libs/gempa/caps/rawpacket.cpp @@ -249,10 +249,12 @@ DataRecord::ReadStatus RawDataRecord::getData(streambuf &buf, int size, _startTime = timestampToTime(_header.samplingTime); if ( _header.samplingFrequencyDenominator > 0 && - _header.samplingFrequencyNumerator > 0 ) + _header.samplingFrequencyNumerator > 0 ) { _endTime = _startTime + samplesToTimeSpan(_header, sampleCount); - else + } + else { _endTime = Time(); + } if ( (start.valid() || end.valid()) && _endTime.valid() ) { // Out of bounds? @@ -265,15 +267,16 @@ DataRecord::ReadStatus RawDataRecord::getData(streambuf &buf, int size, // Trim packet front if ( _startTime < start ) { TimeSpan ofs = start - _startTime; - sampleOfs = timeSpanToSamplesCeil(_header, ofs); + sampleOfs = timeSpanToSamplesFloor(_header, ofs); sampleCount -= sampleOfs; CAPS_DEBUG("Triming packet start: added offset of %d samples", sampleOfs); _startTime += samplesToTimeSpan(_header, sampleOfs); // Update header timespan timeToTimestamp(_header.samplingTime, _startTime); } - else + else { sampleOfs = 0; + } if ( maxBytes > 0 ) { int maxSamples = maxBytes / dataTypeSize; @@ -296,10 +299,13 @@ DataRecord::ReadStatus RawDataRecord::getData(streambuf &buf, int size, CAPS_DEBUG("Triming packet end: added offset of %d samples", trimEnd); } } - else + else { sampleOfs = 0; + } - if ( sampleCount == 0 ) return RS_Error; + if ( sampleCount == 0 ) { + return RS_Error; + } _currentHeader = _header; diff --git a/libs/gempa/caps/url.cpp b/libs/gempa/caps/url.cpp new file mode 100644 index 0000000..f60edec --- /dev/null +++ b/libs/gempa/caps/url.cpp @@ -0,0 +1,77 @@ +/*************************************************************************** + * Copyright (C) 2021 by gempa GmbH * + * * + * All Rights Reserved. * + * * + * NOTICE: All information contained herein is, and remains * + * the property of gempa GmbH and its suppliers, if any. The intellectual * + * and technical concepts contained herein are proprietary to gempa GmbH * + * and its suppliers. * + * Dissemination of this information or reproduction of this material * + * is strictly forbidden unless prior written permission is obtained * + * from gempa GmbH. * + ***************************************************************************/ + + +#include "url.h" +#include "utils.h" + +#include + +using namespace std; + +namespace { + +const string CAPS_PROTOCOL = "caps"; +const string CAPS_SSL_PROTOCOL = "capss"; + +} + +namespace Gempa { +namespace CAPS { + +Url::Url() +: port(0) {} + +bool Url::parse(const string &address, uint16_t defaultPort) { + string addr = trim(address); + + // step 1: protocol + size_t pos = addr.find("://"); + if ( pos == string::npos ) { + protocol = CAPS_PROTOCOL; + } + else { + protocol = addr.substr(0, pos); + addr = addr.substr(pos + 3); + } + + if ( !boost::iequals(protocol, CAPS_PROTOCOL) && + !boost::iequals(protocol, CAPS_SSL_PROTOCOL) ) { + errorString = "Unsupported protocol: %" + protocol; + return false; + } + + // step 2: user:pass + vector toks; + boost::split(toks, addr, boost::is_any_of("@"), boost::token_compress_on); + if ( toks.size() >= 2 ) { + string login = toks[0]; + addr = toks[1]; + boost::split(toks, login, boost::is_any_of(":"), boost::token_compress_on); + user = toks.size() > 0 ? toks[0] : ""; + password = toks.size() > 1 ? toks[1] : ""; + } + + // step 3: address + if ( !splitAddress(host, port, addr, defaultPort) ) { + errorString = "Wrong address format, expected " + "[[caps|capss]://][user:pass@]host[:port]"; + return false; + } + + return true; +} + +} +} diff --git a/libs/gempa/caps/url.h b/libs/gempa/caps/url.h new file mode 100644 index 0000000..d8e664a --- /dev/null +++ b/libs/gempa/caps/url.h @@ -0,0 +1,47 @@ +/*************************************************************************** + * Copyright (C) 2021 by gempa GmbH * + * * + * All Rights Reserved. * + * * + * NOTICE: All information contained herein is, and remains * + * the property of gempa GmbH and its suppliers, if any. The intellectual * + * and technical concepts contained herein are proprietary to gempa GmbH * + * and its suppliers. * + * Dissemination of this information or reproduction of this material * + * is strictly forbidden unless prior written permission is obtained * + * from gempa GmbH. * + ***************************************************************************/ + + +#ifndef GEMPA_CAPS_URL_H +#define GEMPA_CAPS_URL_H + +#include + +namespace Gempa { +namespace CAPS { + +struct Url { + Url(); + + /** + * @brief Reads url parameters from address string. The + * addr format is [[caps|capss]://][user:pass@]host[:port]. + * @param address The address as string + * @param defaultPort Default port + * @return True if the address could be parsed + */ + bool parse(const std::string &address, uint16_t defaultPort = 18002); + + std::string host; + uint16_t port; + std::string user; + std::string password; + std::string protocol; + std::string errorString; +}; + +} +} + +#endif diff --git a/libs/gempa/caps/version.h b/libs/gempa/caps/version.h index a90477b..dae4510 100644 --- a/libs/gempa/caps/version.h +++ b/libs/gempa/caps/version.h @@ -6,8 +6,8 @@ ***************************************************************************/ -#ifndef __GEMPA_CAPS_VERSION_H__ -#define __GEMPA_CAPS_VERSION_H__ +#ifndef GEMPA_CAPS_VERSION_H +#define GEMPA_CAPS_VERSION_H /* #if (LIB_CAPS_VERSION >= LIB_CAPS_VERSION_CHECK(1, 0, 0)) */ @@ -19,14 +19,23 @@ /* LIB_CAPS_VERSION is (major << 16) + (minor << 8) + patch. */ #define LIB_CAPS_VERSION 0x010000 -#define LIB_CAPS_VERSION_NAME "1.0.0" +#define LIB_CAPS_VERSION_NAME "2.0.0" /****************************************************************************** API Changelog ****************************************************************************** + "2.0.0" 0x020000 + - Add Plugin::setAddress + - Add Plugin::flushEncoders + - Add Plugin::dumpPackets + - Add Plugin::packetBuffer + - Add Plugin::setAgent + - Add Plugin::getAPIVersion + - Change Plugin memory layout + "1.0.0" 0x010000 - Initial version */ -#endif // __GEMPA_CAPS_VERSION_H__ +#endif // GEMPA_CAPS_VERSION_H diff --git a/libs/swig/gempa/CAPS.py b/libs/swig/gempa/CAPS.py index 86afe85..255d890 100644 --- a/libs/swig/gempa/CAPS.py +++ b/libs/swig/gempa/CAPS.py @@ -1,113 +1,72 @@ # This file was automatically generated by SWIG (http://www.swig.org). -# Version 3.0.12 +# Version 4.0.2 # # 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): - def swig_import_helper(): - import importlib - pkg = __name__.rpartition('.')[0] - mname = '.'.join((pkg, '_CAPS')).lstrip('.') - try: - return importlib.import_module(mname) - except ImportError: - return importlib.import_module('_CAPS') - _CAPS = swig_import_helper() - del swig_import_helper -elif _swig_python_version_info >= (2, 6, 0): - def swig_import_helper(): - from os.path import dirname - import imp - fp = None - try: - fp, pathname, description = imp.find_module('_CAPS', [dirname(__file__)]) - except ImportError: - import _CAPS - return _CAPS - try: - _mod = imp.load_module('_CAPS', fp, pathname, description) - finally: - if fp is not None: - fp.close() - return _mod - _CAPS = swig_import_helper() - del swig_import_helper +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 _CAPS else: import _CAPS -del _swig_python_version_info - -try: - _swig_property = property -except NameError: - pass # Python < 2.2 doesn't have 'property'. try: 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): - if _newclass: - object.__setattr__(self, name, value) +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +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: - self.__dict__[name] = value - else: - raise AttributeError("You cannot add attributes to %s" % self) + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr -def _swig_setattr(self, class_type, name, value): - return _swig_setattr_nondynamic(self, class_type, name, value, 0) +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_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_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 -def _swig_repr(self): - try: - strthis = "proxy of " + self.this.__repr__() - except __builtin__.Exception: - strthis = "" - return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) -try: - _object = object - _newclass = 1 -except __builtin__.Exception: - class _object: - pass - _newclass = 0 - -class TimeSpan(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, TimeSpan, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, TimeSpan, name) + +class TimeSpan(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_TimeSpan(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.TimeSpan_swiginit(self, _CAPS.new_TimeSpan(*args)) def __eq__(self, arg2): return _CAPS.TimeSpan___eq__(self, arg2) @@ -160,27 +119,16 @@ class TimeSpan(_object): def elapsedTime(self, days, hours=None, minutes=None, seconds=None): return _CAPS.TimeSpan_elapsedTime(self, days, hours, minutes, seconds) __swig_destroy__ = _CAPS.delete_TimeSpan - __del__ = lambda self: None -TimeSpan_swigregister = _CAPS.TimeSpan_swigregister -TimeSpan_swigregister(TimeSpan) + +# Register TimeSpan in _CAPS: +_CAPS.TimeSpan_swigregister(TimeSpan) class Time(TimeSpan): - __swig_setmethods__ = {} - for _s in [TimeSpan]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, Time, name, value) - __swig_getmethods__ = {} - for _s in [TimeSpan]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, Time, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_Time(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Time_swiginit(self, _CAPS.new_Time(*args)) def __nonzero__(self): return _CAPS.Time___nonzero__(self) @@ -208,18 +156,18 @@ class Time(TimeSpan): def get2(self, year, yday=None, hour=None, min=None, sec=None, usec=None): return _CAPS.Time_get2(self, year, yday, hour, min, sec, usec) - if _newclass: - LocalTime = staticmethod(_CAPS.Time_LocalTime) - else: - LocalTime = _CAPS.Time_LocalTime - if _newclass: - GMT = staticmethod(_CAPS.Time_GMT) - else: - GMT = _CAPS.Time_GMT - if _newclass: - FromYearDay = staticmethod(_CAPS.Time_FromYearDay) - else: - FromYearDay = _CAPS.Time_FromYearDay + + @staticmethod + def LocalTime(): + return _CAPS.Time_LocalTime() + + @staticmethod + def GMT(): + return _CAPS.Time_GMT() + + @staticmethod + def FromYearDay(year, year_day): + return _CAPS.Time_FromYearDay(year, year_day) def localtime(self): return _CAPS.Time_localtime(self) @@ -244,32 +192,28 @@ class Time(TimeSpan): def fromString(self, str, fmt): return _CAPS.Time_fromString(self, str, fmt) - if _newclass: - FromString = staticmethod(_CAPS.Time_FromString) - else: - FromString = _CAPS.Time_FromString + + @staticmethod + def FromString(str, fmt): + return _CAPS.Time_FromString(str, fmt) __swig_destroy__ = _CAPS.delete_Time - __del__ = lambda self: None -Time_swigregister = _CAPS.Time_swigregister -Time_swigregister(Time) + +# Register Time in _CAPS: +_CAPS.Time_swigregister(Time) cvar = _CAPS.cvar Time.Null = _CAPS.cvar.Time_Null def Time_LocalTime(): return _CAPS.Time_LocalTime() -Time_LocalTime = _CAPS.Time_LocalTime def Time_GMT(): return _CAPS.Time_GMT() -Time_GMT = _CAPS.Time_GMT def Time_FromYearDay(year, year_day): return _CAPS.Time_FromYearDay(year, year_day) -Time_FromYearDay = _CAPS.Time_FromYearDay def Time_FromString(str, fmt): return _CAPS.Time_FromString(str, fmt) -Time_FromString = _CAPS.Time_FromString UnknownPacket = _CAPS.UnknownPacket RawDataPacket = _CAPS.RawDataPacket @@ -286,129 +230,59 @@ DT_INT64 = _CAPS.DT_INT64 DT_INT32 = _CAPS.DT_INT32 DT_INT16 = _CAPS.DT_INT16 DT_INT8 = _CAPS.DT_INT8 -class UOM(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, UOM, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, UOM, name) +class UOM(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["str"] = _CAPS.UOM_str_set - __swig_getmethods__["str"] = _CAPS.UOM_str_get - if _newclass: - str = _swig_property(_CAPS.UOM_str_get, _CAPS.UOM_str_set) - __swig_setmethods__["ID"] = _CAPS.UOM_ID_set - __swig_getmethods__["ID"] = _CAPS.UOM_ID_get - if _newclass: - ID = _swig_property(_CAPS.UOM_ID_get, _CAPS.UOM_ID_set) + str = property(_CAPS.UOM_str_get, _CAPS.UOM_str_set) + ID = property(_CAPS.UOM_ID_get, _CAPS.UOM_ID_set) def __init__(self): - this = _CAPS.new_UOM() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.UOM_swiginit(self, _CAPS.new_UOM()) __swig_destroy__ = _CAPS.delete_UOM - __del__ = lambda self: None -UOM_swigregister = _CAPS.UOM_swigregister -UOM_swigregister(UOM) - -class Quality(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Quality, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Quality, name) + +# Register UOM in _CAPS: +_CAPS.UOM_swigregister(UOM) + +class Quality(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["str"] = _CAPS.Quality_str_set - __swig_getmethods__["str"] = _CAPS.Quality_str_get - if _newclass: - str = _swig_property(_CAPS.Quality_str_get, _CAPS.Quality_str_set) - __swig_setmethods__["ID"] = _CAPS.Quality_ID_set - __swig_getmethods__["ID"] = _CAPS.Quality_ID_get - if _newclass: - ID = _swig_property(_CAPS.Quality_ID_get, _CAPS.Quality_ID_set) + str = property(_CAPS.Quality_str_get, _CAPS.Quality_str_set) + ID = property(_CAPS.Quality_ID_get, _CAPS.Quality_ID_set) def __init__(self): - this = _CAPS.new_Quality() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Quality_swiginit(self, _CAPS.new_Quality()) __swig_destroy__ = _CAPS.delete_Quality - __del__ = lambda self: None -Quality_swigregister = _CAPS.Quality_swigregister -Quality_swigregister(Quality) - -class TimeStamp(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, TimeStamp, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, TimeStamp, name) + +# Register Quality in _CAPS: +_CAPS.Quality_swigregister(Quality) + +class TimeStamp(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["year"] = _CAPS.TimeStamp_year_set - __swig_getmethods__["year"] = _CAPS.TimeStamp_year_get - if _newclass: - year = _swig_property(_CAPS.TimeStamp_year_get, _CAPS.TimeStamp_year_set) - __swig_setmethods__["yday"] = _CAPS.TimeStamp_yday_set - __swig_getmethods__["yday"] = _CAPS.TimeStamp_yday_get - if _newclass: - yday = _swig_property(_CAPS.TimeStamp_yday_get, _CAPS.TimeStamp_yday_set) - __swig_setmethods__["hour"] = _CAPS.TimeStamp_hour_set - __swig_getmethods__["hour"] = _CAPS.TimeStamp_hour_get - if _newclass: - hour = _swig_property(_CAPS.TimeStamp_hour_get, _CAPS.TimeStamp_hour_set) - __swig_setmethods__["minute"] = _CAPS.TimeStamp_minute_set - __swig_getmethods__["minute"] = _CAPS.TimeStamp_minute_get - if _newclass: - minute = _swig_property(_CAPS.TimeStamp_minute_get, _CAPS.TimeStamp_minute_set) - __swig_setmethods__["second"] = _CAPS.TimeStamp_second_set - __swig_getmethods__["second"] = _CAPS.TimeStamp_second_get - if _newclass: - second = _swig_property(_CAPS.TimeStamp_second_get, _CAPS.TimeStamp_second_set) - __swig_setmethods__["unused"] = _CAPS.TimeStamp_unused_set - __swig_getmethods__["unused"] = _CAPS.TimeStamp_unused_get - if _newclass: - unused = _swig_property(_CAPS.TimeStamp_unused_get, _CAPS.TimeStamp_unused_set) - __swig_setmethods__["usec"] = _CAPS.TimeStamp_usec_set - __swig_getmethods__["usec"] = _CAPS.TimeStamp_usec_get - if _newclass: - usec = _swig_property(_CAPS.TimeStamp_usec_get, _CAPS.TimeStamp_usec_set) + year = property(_CAPS.TimeStamp_year_get, _CAPS.TimeStamp_year_set) + yday = property(_CAPS.TimeStamp_yday_get, _CAPS.TimeStamp_yday_set) + hour = property(_CAPS.TimeStamp_hour_get, _CAPS.TimeStamp_hour_set) + minute = property(_CAPS.TimeStamp_minute_get, _CAPS.TimeStamp_minute_set) + second = property(_CAPS.TimeStamp_second_get, _CAPS.TimeStamp_second_set) + unused = property(_CAPS.TimeStamp_unused_get, _CAPS.TimeStamp_unused_set) + usec = property(_CAPS.TimeStamp_usec_get, _CAPS.TimeStamp_usec_set) def __init__(self): - this = _CAPS.new_TimeStamp() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.TimeStamp_swiginit(self, _CAPS.new_TimeStamp()) __swig_destroy__ = _CAPS.delete_TimeStamp - __del__ = lambda self: None -TimeStamp_swigregister = _CAPS.TimeStamp_swigregister -TimeStamp_swigregister(TimeStamp) - -class PacketDataHeader(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, PacketDataHeader, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, PacketDataHeader, name) + +# Register TimeStamp in _CAPS: +_CAPS.TimeStamp_swigregister(TimeStamp) + +class PacketDataHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_PacketDataHeader(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this - __swig_setmethods__["version"] = _CAPS.PacketDataHeader_version_set - __swig_getmethods__["version"] = _CAPS.PacketDataHeader_version_get - if _newclass: - version = _swig_property(_CAPS.PacketDataHeader_version_get, _CAPS.PacketDataHeader_version_set) - __swig_setmethods__["packetType"] = _CAPS.PacketDataHeader_packetType_set - __swig_getmethods__["packetType"] = _CAPS.PacketDataHeader_packetType_get - if _newclass: - packetType = _swig_property(_CAPS.PacketDataHeader_packetType_get, _CAPS.PacketDataHeader_packetType_set) - __swig_setmethods__["unitOfMeasurement"] = _CAPS.PacketDataHeader_unitOfMeasurement_set - __swig_getmethods__["unitOfMeasurement"] = _CAPS.PacketDataHeader_unitOfMeasurement_get - if _newclass: - unitOfMeasurement = _swig_property(_CAPS.PacketDataHeader_unitOfMeasurement_get, _CAPS.PacketDataHeader_unitOfMeasurement_set) + _CAPS.PacketDataHeader_swiginit(self, _CAPS.new_PacketDataHeader(*args)) + version = property(_CAPS.PacketDataHeader_version_get, _CAPS.PacketDataHeader_version_set) + packetType = property(_CAPS.PacketDataHeader_packetType_get, _CAPS.PacketDataHeader_packetType_set) + unitOfMeasurement = property(_CAPS.PacketDataHeader_unitOfMeasurement_get, _CAPS.PacketDataHeader_unitOfMeasurement_set) def setUOM(self, type): return _CAPS.PacketDataHeader_setUOM(self, type) @@ -428,39 +302,19 @@ class PacketDataHeader(_object): def get(self, buf): return _CAPS.PacketDataHeader_get(self, buf) __swig_destroy__ = _CAPS.delete_PacketDataHeader - __del__ = lambda self: None -PacketDataHeader_swigregister = _CAPS.PacketDataHeader_swigregister -PacketDataHeader_swigregister(PacketDataHeader) + +# Register PacketDataHeader in _CAPS: +_CAPS.PacketDataHeader_swigregister(PacketDataHeader) class PacketDataHeaderV2(PacketDataHeader): - __swig_setmethods__ = {} - for _s in [PacketDataHeader]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, PacketDataHeaderV2, name, value) - __swig_getmethods__ = {} - for _s in [PacketDataHeader]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, PacketDataHeaderV2, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self): - this = _CAPS.new_PacketDataHeaderV2() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this - __swig_setmethods__["samplingFrequencyNumerator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set - __swig_getmethods__["samplingFrequencyNumerator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get - if _newclass: - samplingFrequencyNumerator = _swig_property(_CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set) - __swig_setmethods__["samplingFrequencyDenominator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set - __swig_getmethods__["samplingFrequencyDenominator"] = _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get - if _newclass: - samplingFrequencyDenominator = _swig_property(_CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set) - __swig_setmethods__["quality"] = _CAPS.PacketDataHeaderV2_quality_set - __swig_getmethods__["quality"] = _CAPS.PacketDataHeaderV2_quality_get - if _newclass: - quality = _swig_property(_CAPS.PacketDataHeaderV2_quality_get, _CAPS.PacketDataHeaderV2_quality_set) + _CAPS.PacketDataHeaderV2_swiginit(self, _CAPS.new_PacketDataHeaderV2()) + samplingFrequencyNumerator = property(_CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyNumerator_set) + samplingFrequencyDenominator = property(_CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_get, _CAPS.PacketDataHeaderV2_samplingFrequencyDenominator_set) + quality = property(_CAPS.PacketDataHeaderV2_quality_get, _CAPS.PacketDataHeaderV2_quality_set) def __ne__(self, other): return _CAPS.PacketDataHeaderV2___ne__(self, other) @@ -474,29 +328,20 @@ class PacketDataHeaderV2(PacketDataHeader): def get(self, buf): return _CAPS.PacketDataHeaderV2_get(self, buf) __swig_destroy__ = _CAPS.delete_PacketDataHeaderV2 - __del__ = lambda self: None -PacketDataHeaderV2_swigregister = _CAPS.PacketDataHeaderV2_swigregister -PacketDataHeaderV2_swigregister(PacketDataHeaderV2) + +# Register PacketDataHeaderV2 in _CAPS: +_CAPS.PacketDataHeaderV2_swigregister(PacketDataHeaderV2) NetworkCode = _CAPS.NetworkCode StationCode = _CAPS.StationCode LocationCode = _CAPS.LocationCode ChannelCode = _CAPS.ChannelCode StreamIDComponentSize = _CAPS.StreamIDComponentSize -class PacketHeaderV1(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, PacketHeaderV1, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, PacketHeaderV1, name) +class PacketHeaderV1(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["SIDSize"] = _CAPS.PacketHeaderV1_SIDSize_set - __swig_getmethods__["SIDSize"] = _CAPS.PacketHeaderV1_SIDSize_get - if _newclass: - SIDSize = _swig_property(_CAPS.PacketHeaderV1_SIDSize_get, _CAPS.PacketHeaderV1_SIDSize_set) - __swig_setmethods__["size"] = _CAPS.PacketHeaderV1_size_set - __swig_getmethods__["size"] = _CAPS.PacketHeaderV1_size_get - if _newclass: - size = _swig_property(_CAPS.PacketHeaderV1_size_get, _CAPS.PacketHeaderV1_size_set) + SIDSize = property(_CAPS.PacketHeaderV1_SIDSize_get, _CAPS.PacketHeaderV1_SIDSize_set) + size = property(_CAPS.PacketHeaderV1_size_get, _CAPS.PacketHeaderV1_size_set) def put(self, buf): return _CAPS.PacketHeaderV1_put(self, buf) @@ -505,30 +350,17 @@ class PacketHeaderV1(_object): return _CAPS.PacketHeaderV1_dataSize(self) def __init__(self): - this = _CAPS.new_PacketHeaderV1() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.PacketHeaderV1_swiginit(self, _CAPS.new_PacketHeaderV1()) __swig_destroy__ = _CAPS.delete_PacketHeaderV1 - __del__ = lambda self: None -PacketHeaderV1_swigregister = _CAPS.PacketHeaderV1_swigregister -PacketHeaderV1_swigregister(PacketHeaderV1) - -class PacketHeaderV2(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, PacketHeaderV2, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, PacketHeaderV2, name) + +# Register PacketHeaderV1 in _CAPS: +_CAPS.PacketHeaderV1_swigregister(PacketHeaderV1) + +class PacketHeaderV2(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["SIDSize"] = _CAPS.PacketHeaderV2_SIDSize_set - __swig_getmethods__["SIDSize"] = _CAPS.PacketHeaderV2_SIDSize_get - if _newclass: - SIDSize = _swig_property(_CAPS.PacketHeaderV2_SIDSize_get, _CAPS.PacketHeaderV2_SIDSize_set) - __swig_setmethods__["size"] = _CAPS.PacketHeaderV2_size_set - __swig_getmethods__["size"] = _CAPS.PacketHeaderV2_size_get - if _newclass: - size = _swig_property(_CAPS.PacketHeaderV2_size_get, _CAPS.PacketHeaderV2_size_set) + SIDSize = property(_CAPS.PacketHeaderV2_SIDSize_get, _CAPS.PacketHeaderV2_SIDSize_set) + size = property(_CAPS.PacketHeaderV2_size_get, _CAPS.PacketHeaderV2_size_set) def put(self, buf): return _CAPS.PacketHeaderV2_put(self, buf) @@ -537,50 +369,30 @@ class PacketHeaderV2(_object): return _CAPS.PacketHeaderV2_dataSize(self) def __init__(self): - this = _CAPS.new_PacketHeaderV2() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.PacketHeaderV2_swiginit(self, _CAPS.new_PacketHeaderV2()) __swig_destroy__ = _CAPS.delete_PacketHeaderV2 - __del__ = lambda self: None -PacketHeaderV2_swigregister = _CAPS.PacketHeaderV2_swigregister -PacketHeaderV2_swigregister(PacketHeaderV2) - -class ResponseHeader(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, ResponseHeader, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, ResponseHeader, name) + +# Register PacketHeaderV2 in _CAPS: +_CAPS.PacketHeaderV2_swigregister(PacketHeaderV2) + +class ResponseHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["id"] = _CAPS.ResponseHeader_id_set - __swig_getmethods__["id"] = _CAPS.ResponseHeader_id_get - if _newclass: - id = _swig_property(_CAPS.ResponseHeader_id_get, _CAPS.ResponseHeader_id_set) - __swig_setmethods__["size"] = _CAPS.ResponseHeader_size_set - __swig_getmethods__["size"] = _CAPS.ResponseHeader_size_get - if _newclass: - size = _swig_property(_CAPS.ResponseHeader_size_get, _CAPS.ResponseHeader_size_set) + id = property(_CAPS.ResponseHeader_id_get, _CAPS.ResponseHeader_id_set) + size = property(_CAPS.ResponseHeader_size_get, _CAPS.ResponseHeader_size_set) def get(self, buf): return _CAPS.ResponseHeader_get(self, buf) def __init__(self): - this = _CAPS.new_ResponseHeader() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.ResponseHeader_swiginit(self, _CAPS.new_ResponseHeader()) __swig_destroy__ = _CAPS.delete_ResponseHeader - __del__ = lambda self: None -ResponseHeader_swigregister = _CAPS.ResponseHeader_swigregister -ResponseHeader_swigregister(ResponseHeader) -class DataRecord(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, DataRecord, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, DataRecord, name) +# Register ResponseHeader in _CAPS: +_CAPS.ResponseHeader_swigregister(ResponseHeader) + +class DataRecord(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -592,7 +404,6 @@ class DataRecord(_object): RS_AfterTimeWindow = _CAPS.DataRecord_RS_AfterTimeWindow RS_Max = _CAPS.DataRecord_RS_Max __swig_destroy__ = _CAPS.delete_DataRecord - __del__ = lambda self: None def formatName(self): return _CAPS.DataRecord_formatName(self) @@ -635,174 +446,77 @@ class DataRecord(_object): def data(self): return _CAPS.DataRecord_data(self) -DataRecord_swigregister = _CAPS.DataRecord_swigregister -DataRecord_swigregister(DataRecord) - -class RawPacket(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, RawPacket, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, RawPacket, name) + +# Register DataRecord in _CAPS: +_CAPS.DataRecord_swigregister(DataRecord) + +class RawPacket(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["header"] = _CAPS.RawPacket_header_set - __swig_getmethods__["header"] = _CAPS.RawPacket_header_get - if _newclass: - header = _swig_property(_CAPS.RawPacket_header_get, _CAPS.RawPacket_header_set) - __swig_setmethods__["SID"] = _CAPS.RawPacket_SID_set - __swig_getmethods__["SID"] = _CAPS.RawPacket_SID_get - if _newclass: - SID = _swig_property(_CAPS.RawPacket_SID_get, _CAPS.RawPacket_SID_set) - __swig_setmethods__["data"] = _CAPS.RawPacket_data_set - __swig_getmethods__["data"] = _CAPS.RawPacket_data_get - if _newclass: - data = _swig_property(_CAPS.RawPacket_data_get, _CAPS.RawPacket_data_set) - __swig_setmethods__["record"] = _CAPS.RawPacket_record_set - __swig_getmethods__["record"] = _CAPS.RawPacket_record_get - if _newclass: - record = _swig_property(_CAPS.RawPacket_record_get, _CAPS.RawPacket_record_set) + header = property(_CAPS.RawPacket_header_get, _CAPS.RawPacket_header_set) + SID = property(_CAPS.RawPacket_SID_get, _CAPS.RawPacket_SID_set) + data = property(_CAPS.RawPacket_data_get, _CAPS.RawPacket_data_set) + record = property(_CAPS.RawPacket_record_get, _CAPS.RawPacket_record_set) def __init__(self): - this = _CAPS.new_RawPacket() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.RawPacket_swiginit(self, _CAPS.new_RawPacket()) __swig_destroy__ = _CAPS.delete_RawPacket - __del__ = lambda self: None -RawPacket_swigregister = _CAPS.RawPacket_swigregister -RawPacket_swigregister(RawPacket) - -class MetaPacket(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, MetaPacket, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, MetaPacket, name) + +# Register RawPacket in _CAPS: +_CAPS.RawPacket_swigregister(RawPacket) + +class MetaPacket(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["SID"] = _CAPS.MetaPacket_SID_set - __swig_getmethods__["SID"] = _CAPS.MetaPacket_SID_get - if _newclass: - SID = _swig_property(_CAPS.MetaPacket_SID_get, _CAPS.MetaPacket_SID_set) - __swig_setmethods__["packetDataHeader"] = _CAPS.MetaPacket_packetDataHeader_set - __swig_getmethods__["packetDataHeader"] = _CAPS.MetaPacket_packetDataHeader_get - if _newclass: - packetDataHeader = _swig_property(_CAPS.MetaPacket_packetDataHeader_get, _CAPS.MetaPacket_packetDataHeader_set) - __swig_setmethods__["record"] = _CAPS.MetaPacket_record_set - __swig_getmethods__["record"] = _CAPS.MetaPacket_record_get - if _newclass: - record = _swig_property(_CAPS.MetaPacket_record_get, _CAPS.MetaPacket_record_set) - __swig_setmethods__["recordHeader"] = _CAPS.MetaPacket_recordHeader_set - __swig_getmethods__["recordHeader"] = _CAPS.MetaPacket_recordHeader_get - if _newclass: - recordHeader = _swig_property(_CAPS.MetaPacket_recordHeader_get, _CAPS.MetaPacket_recordHeader_set) - __swig_setmethods__["startTime"] = _CAPS.MetaPacket_startTime_set - __swig_getmethods__["startTime"] = _CAPS.MetaPacket_startTime_get - if _newclass: - startTime = _swig_property(_CAPS.MetaPacket_startTime_get, _CAPS.MetaPacket_startTime_set) - __swig_setmethods__["endTime"] = _CAPS.MetaPacket_endTime_set - __swig_getmethods__["endTime"] = _CAPS.MetaPacket_endTime_get - if _newclass: - endTime = _swig_property(_CAPS.MetaPacket_endTime_get, _CAPS.MetaPacket_endTime_set) - __swig_setmethods__["timestamp"] = _CAPS.MetaPacket_timestamp_set - __swig_getmethods__["timestamp"] = _CAPS.MetaPacket_timestamp_get - if _newclass: - timestamp = _swig_property(_CAPS.MetaPacket_timestamp_get, _CAPS.MetaPacket_timestamp_set) + SID = property(_CAPS.MetaPacket_SID_get, _CAPS.MetaPacket_SID_set) + packetDataHeader = property(_CAPS.MetaPacket_packetDataHeader_get, _CAPS.MetaPacket_packetDataHeader_set) + record = property(_CAPS.MetaPacket_record_get, _CAPS.MetaPacket_record_set) + recordHeader = property(_CAPS.MetaPacket_recordHeader_get, _CAPS.MetaPacket_recordHeader_set) + startTime = property(_CAPS.MetaPacket_startTime_get, _CAPS.MetaPacket_startTime_set) + endTime = property(_CAPS.MetaPacket_endTime_get, _CAPS.MetaPacket_endTime_set) + timestamp = property(_CAPS.MetaPacket_timestamp_get, _CAPS.MetaPacket_timestamp_set) def __init__(self): - this = _CAPS.new_MetaPacket() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.MetaPacket_swiginit(self, _CAPS.new_MetaPacket()) __swig_destroy__ = _CAPS.delete_MetaPacket - __del__ = lambda self: None -MetaPacket_swigregister = _CAPS.MetaPacket_swigregister -MetaPacket_swigregister(MetaPacket) - -class Packet(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Packet, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Packet, name) + +# Register MetaPacket in _CAPS: +_CAPS.MetaPacket_swigregister(MetaPacket) + +class Packet(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_Packet(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Packet_swiginit(self, _CAPS.new_Packet(*args)) def clone(self): return _CAPS.Packet_clone(self) - __swig_setmethods__["buffer"] = _CAPS.Packet_buffer_set - __swig_getmethods__["buffer"] = _CAPS.Packet_buffer_get - if _newclass: - buffer = _swig_property(_CAPS.Packet_buffer_get, _CAPS.Packet_buffer_set) - __swig_setmethods__["record"] = _CAPS.Packet_record_set - __swig_getmethods__["record"] = _CAPS.Packet_record_get - if _newclass: - record = _swig_property(_CAPS.Packet_record_get, _CAPS.Packet_record_set) - __swig_setmethods__["networkCode"] = _CAPS.Packet_networkCode_set - __swig_getmethods__["networkCode"] = _CAPS.Packet_networkCode_get - if _newclass: - networkCode = _swig_property(_CAPS.Packet_networkCode_get, _CAPS.Packet_networkCode_set) - __swig_setmethods__["stationCode"] = _CAPS.Packet_stationCode_set - __swig_getmethods__["stationCode"] = _CAPS.Packet_stationCode_get - if _newclass: - stationCode = _swig_property(_CAPS.Packet_stationCode_get, _CAPS.Packet_stationCode_set) - __swig_setmethods__["locationCode"] = _CAPS.Packet_locationCode_set - __swig_getmethods__["locationCode"] = _CAPS.Packet_locationCode_get - if _newclass: - locationCode = _swig_property(_CAPS.Packet_locationCode_get, _CAPS.Packet_locationCode_set) - __swig_setmethods__["channelCode"] = _CAPS.Packet_channelCode_set - __swig_getmethods__["channelCode"] = _CAPS.Packet_channelCode_get - if _newclass: - channelCode = _swig_property(_CAPS.Packet_channelCode_get, _CAPS.Packet_channelCode_set) - __swig_setmethods__["streamID"] = _CAPS.Packet_streamID_set - __swig_getmethods__["streamID"] = _CAPS.Packet_streamID_get - if _newclass: - streamID = _swig_property(_CAPS.Packet_streamID_get, _CAPS.Packet_streamID_set) - __swig_setmethods__["dataType"] = _CAPS.Packet_dataType_set - __swig_getmethods__["dataType"] = _CAPS.Packet_dataType_get - if _newclass: - dataType = _swig_property(_CAPS.Packet_dataType_get, _CAPS.Packet_dataType_set) - __swig_setmethods__["dt_us"] = _CAPS.Packet_dt_us_set - __swig_getmethods__["dt_us"] = _CAPS.Packet_dt_us_get - if _newclass: - dt_us = _swig_property(_CAPS.Packet_dt_us_get, _CAPS.Packet_dt_us_set) - __swig_setmethods__["uom"] = _CAPS.Packet_uom_set - __swig_getmethods__["uom"] = _CAPS.Packet_uom_get - if _newclass: - uom = _swig_property(_CAPS.Packet_uom_get, _CAPS.Packet_uom_set) - __swig_setmethods__["timingQuality"] = _CAPS.Packet_timingQuality_set - __swig_getmethods__["timingQuality"] = _CAPS.Packet_timingQuality_get - if _newclass: - timingQuality = _swig_property(_CAPS.Packet_timingQuality_get, _CAPS.Packet_timingQuality_set) + buffer = property(_CAPS.Packet_buffer_get, _CAPS.Packet_buffer_set) + record = property(_CAPS.Packet_record_get, _CAPS.Packet_record_set) + networkCode = property(_CAPS.Packet_networkCode_get, _CAPS.Packet_networkCode_set) + stationCode = property(_CAPS.Packet_stationCode_get, _CAPS.Packet_stationCode_set) + locationCode = property(_CAPS.Packet_locationCode_get, _CAPS.Packet_locationCode_set) + channelCode = property(_CAPS.Packet_channelCode_get, _CAPS.Packet_channelCode_set) + streamID = property(_CAPS.Packet_streamID_get, _CAPS.Packet_streamID_set) + dataType = property(_CAPS.Packet_dataType_get, _CAPS.Packet_dataType_set) + dt_us = property(_CAPS.Packet_dt_us_get, _CAPS.Packet_dt_us_set) + uom = property(_CAPS.Packet_uom_get, _CAPS.Packet_uom_set) + timingQuality = property(_CAPS.Packet_timingQuality_get, _CAPS.Packet_timingQuality_set) def size(self): return _CAPS.Packet_size(self) __swig_destroy__ = _CAPS.delete_Packet - __del__ = lambda self: None -Packet_swigregister = _CAPS.Packet_swigregister -Packet_swigregister(Packet) + +# Register Packet in _CAPS: +_CAPS.Packet_swigregister(Packet) class AnyDataRecord(DataRecord): - __swig_setmethods__ = {} - for _s in [DataRecord]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, AnyDataRecord, name, value) - __swig_getmethods__ = {} - for _s in [DataRecord]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, AnyDataRecord, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self): - this = _CAPS.new_AnyDataRecord() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.AnyDataRecord_swiginit(self, _CAPS.new_AnyDataRecord()) def setType(self, type): return _CAPS.AnyDataRecord_setType(self, type) @@ -861,9 +575,9 @@ class AnyDataRecord(DataRecord): def setData(self, data, size): return _CAPS.AnyDataRecord_setData(self, data, size) __swig_destroy__ = _CAPS.delete_AnyDataRecord - __del__ = lambda self: None -AnyDataRecord_swigregister = _CAPS.AnyDataRecord_swigregister -AnyDataRecord_swigregister(AnyDataRecord) + +# Register AnyDataRecord in _CAPS: +_CAPS.AnyDataRecord_swigregister(AnyDataRecord) LL_UNDEFINED = _CAPS.LL_UNDEFINED LL_ERROR = _CAPS.LL_ERROR @@ -875,54 +589,38 @@ LL_QUANTITY = _CAPS.LL_QUANTITY def SetLogHandler(arg1, arg2): return _CAPS.SetLogHandler(arg1, arg2) -SetLogHandler = _CAPS.SetLogHandler -class SPClock(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, SPClock, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, SPClock, name) +class SPClock(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_getmethods__["freqn"] = _CAPS.SPClock_freqn_get - if _newclass: - freqn = _swig_property(_CAPS.SPClock_freqn_get) - __swig_getmethods__["freqd"] = _CAPS.SPClock_freqd_get - if _newclass: - freqd = _swig_property(_CAPS.SPClock_freqd_get) - - def __init__(self, freqn_init, freqd_init): - this = _CAPS.new_SPClock(freqn_init, freqd_init) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this - - def sync_time(self, time): - return _CAPS.SPClock_sync_time(self, time) + + def __init__(self, freqn, freqd): + _CAPS.SPClock_swiginit(self, _CAPS.new_SPClock(freqn, freqd)) + + def syncTime(self, time): + return _CAPS.SPClock_syncTime(self, time) def tick(self): return _CAPS.SPClock_tick(self) - def get_time(self, tick_diff): - return _CAPS.SPClock_get_time(self, tick_diff) + def getTime(self, tickDiff): + return _CAPS.SPClock_getTime(self, tickDiff) def correction(self): return _CAPS.SPClock_correction(self) + freqn = property(_CAPS.SPClock_freqn_get) + freqd = property(_CAPS.SPClock_freqd_get) __swig_destroy__ = _CAPS.delete_SPClock - __del__ = lambda self: None -SPClock_swigregister = _CAPS.SPClock_swigregister -SPClock_swigregister(SPClock) -class Encoder(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Encoder, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Encoder, name) +# Register SPClock in _CAPS: +_CAPS.SPClock_swigregister(SPClock) + +class Encoder(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _CAPS.delete_Encoder - __del__ = lambda self: None def push(self, sample): return _CAPS.Encoder_push(self, sample) @@ -953,20 +651,17 @@ class Encoder(_object): def pop(self): return _CAPS.Encoder_pop(self) -Encoder_swigregister = _CAPS.Encoder_swigregister -Encoder_swigregister(Encoder) -class EncoderFactory(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, EncoderFactory, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, EncoderFactory, name) +# Register Encoder in _CAPS: +_CAPS.Encoder_swigregister(Encoder) + +class EncoderFactory(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _CAPS.delete_EncoderFactory - __del__ = lambda self: None def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator): return _CAPS.EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator) @@ -976,18 +671,12 @@ class EncoderFactory(_object): def errorString(self): return _CAPS.EncoderFactory_errorString(self) -EncoderFactory_swigregister = _CAPS.EncoderFactory_swigregister -EncoderFactory_swigregister(EncoderFactory) + +# Register EncoderFactory in _CAPS: +_CAPS.EncoderFactory_swigregister(EncoderFactory) class MSEEDEncoderFactory(EncoderFactory): - __swig_setmethods__ = {} - for _s in [EncoderFactory]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, MSEEDEncoderFactory, name, value) - __swig_getmethods__ = {} - for _s in [EncoderFactory]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, MSEEDEncoderFactory, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -996,19 +685,12 @@ class MSEEDEncoderFactory(EncoderFactory): def setRecordLength(self, recordLength): return _CAPS.MSEEDEncoderFactory_setRecordLength(self, recordLength) __swig_destroy__ = _CAPS.delete_MSEEDEncoderFactory - __del__ = lambda self: None -MSEEDEncoderFactory_swigregister = _CAPS.MSEEDEncoderFactory_swigregister -MSEEDEncoderFactory_swigregister(MSEEDEncoderFactory) + +# Register MSEEDEncoderFactory in _CAPS: +_CAPS.MSEEDEncoderFactory_swigregister(MSEEDEncoderFactory) class SteimEncoderFactory(MSEEDEncoderFactory): - __swig_setmethods__ = {} - for _s in [MSEEDEncoderFactory]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, SteimEncoderFactory, name, value) - __swig_getmethods__ = {} - for _s in [MSEEDEncoderFactory]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, SteimEncoderFactory, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -1017,19 +699,12 @@ class SteimEncoderFactory(MSEEDEncoderFactory): def supportsRecord(self, rec): return _CAPS.SteimEncoderFactory_supportsRecord(self, rec) __swig_destroy__ = _CAPS.delete_SteimEncoderFactory - __del__ = lambda self: None -SteimEncoderFactory_swigregister = _CAPS.SteimEncoderFactory_swigregister -SteimEncoderFactory_swigregister(SteimEncoderFactory) + +# Register SteimEncoderFactory in _CAPS: +_CAPS.SteimEncoderFactory_swigregister(SteimEncoderFactory) class IdentityEncoderFactory(MSEEDEncoderFactory): - __swig_setmethods__ = {} - for _s in [MSEEDEncoderFactory]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, IdentityEncoderFactory, name, value) - __swig_getmethods__ = {} - for _s in [MSEEDEncoderFactory]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, IdentityEncoderFactory, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator): @@ -1039,75 +714,42 @@ class IdentityEncoderFactory(MSEEDEncoderFactory): return _CAPS.IdentityEncoderFactory_supportsRecord(self, rec) def __init__(self): - this = _CAPS.new_IdentityEncoderFactory() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.IdentityEncoderFactory_swiginit(self, _CAPS.new_IdentityEncoderFactory()) __swig_destroy__ = _CAPS.delete_IdentityEncoderFactory - __del__ = lambda self: None -IdentityEncoderFactory_swigregister = _CAPS.IdentityEncoderFactory_swigregister -IdentityEncoderFactory_swigregister(IdentityEncoderFactory) + +# Register IdentityEncoderFactory in _CAPS: +_CAPS.IdentityEncoderFactory_swigregister(IdentityEncoderFactory) class Steim1EncoderFactory(SteimEncoderFactory): - __swig_setmethods__ = {} - for _s in [SteimEncoderFactory]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, Steim1EncoderFactory, name, value) - __swig_getmethods__ = {} - for _s in [SteimEncoderFactory]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, Steim1EncoderFactory, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator): return _CAPS.Steim1EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator) def __init__(self): - this = _CAPS.new_Steim1EncoderFactory() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Steim1EncoderFactory_swiginit(self, _CAPS.new_Steim1EncoderFactory()) __swig_destroy__ = _CAPS.delete_Steim1EncoderFactory - __del__ = lambda self: None -Steim1EncoderFactory_swigregister = _CAPS.Steim1EncoderFactory_swigregister -Steim1EncoderFactory_swigregister(Steim1EncoderFactory) + +# Register Steim1EncoderFactory in _CAPS: +_CAPS.Steim1EncoderFactory_swigregister(Steim1EncoderFactory) class Steim2EncoderFactory(SteimEncoderFactory): - __swig_setmethods__ = {} - for _s in [SteimEncoderFactory]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, Steim2EncoderFactory, name, value) - __swig_getmethods__ = {} - for _s in [SteimEncoderFactory]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, Steim2EncoderFactory, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator): return _CAPS.Steim2EncoderFactory_create(self, networkCode, stationCode, locationCode, channelCode, dt, samplingFrequencyNumerator, samplingFrequencyDenominator) def __init__(self): - this = _CAPS.new_Steim2EncoderFactory() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Steim2EncoderFactory_swiginit(self, _CAPS.new_Steim2EncoderFactory()) __swig_destroy__ = _CAPS.delete_Steim2EncoderFactory - __del__ = lambda self: None -Steim2EncoderFactory_swigregister = _CAPS.Steim2EncoderFactory_swigregister -Steim2EncoderFactory_swigregister(Steim2EncoderFactory) + +# Register Steim2EncoderFactory in _CAPS: +_CAPS.Steim2EncoderFactory_swigregister(Steim2EncoderFactory) class MSEEDDataRecord(DataRecord): - __swig_setmethods__ = {} - for _s in [DataRecord]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, MSEEDDataRecord, name, value) - __swig_getmethods__ = {} - for _s in [DataRecord]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, MSEEDDataRecord, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -1155,15 +797,12 @@ class MSEEDDataRecord(DataRecord): def unpackHeader(self): return _CAPS.MSEEDDataRecord_unpackHeader(self) __swig_destroy__ = _CAPS.delete_MSEEDDataRecord - __del__ = lambda self: None -MSEEDDataRecord_swigregister = _CAPS.MSEEDDataRecord_swigregister -MSEEDDataRecord_swigregister(MSEEDDataRecord) - -class Plugin(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Plugin, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Plugin, name) + +# Register MSEEDDataRecord in _CAPS: +_CAPS.MSEEDDataRecord_swigregister(MSEEDDataRecord) + +class Plugin(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr Success = _CAPS.Plugin_Success PacketSize = _CAPS.Plugin_PacketSize @@ -1173,13 +812,8 @@ class Plugin(_object): MaxFutureEndTimeExceeded = _CAPS.Plugin_MaxFutureEndTimeExceeded def __init__(self, *args): - this = _CAPS.new_Plugin(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Plugin_swiginit(self, _CAPS.new_Plugin(*args)) __swig_destroy__ = _CAPS.delete_Plugin - __del__ = lambda self: None def close(self): return _CAPS.Plugin_close(self) @@ -1208,6 +842,9 @@ class Plugin(_object): def setEncoderFactory(self, factory): return _CAPS.Plugin_setEncoderFactory(self, factory) + def setAddress(self, addr, defaultPort=18003): + return _CAPS.Plugin_setAddress(self, addr, defaultPort) + def setHost(self, host): return _CAPS.Plugin_setHost(self, host) @@ -1259,28 +896,32 @@ class Plugin(_object): def writeJournal(self, *args): return _CAPS.Plugin_writeJournal(self, *args) + def flushEncoders(self): + return _CAPS.Plugin_flushEncoders(self) + + def dumpPackets(self, enable): + return _CAPS.Plugin_dumpPackets(self, enable) + + def packetBuffer(self): + return _CAPS.Plugin_packetBuffer(self) + + def setAgent(self, agent): + return _CAPS.Plugin_setAgent(self, agent) + def version(self): return _CAPS.Plugin_version(self) def push(self, *args): return _CAPS.Plugin_push(self, *args) -Plugin_swigregister = _CAPS.Plugin_swigregister -Plugin_swigregister(Plugin) - -class RawResponseHeader(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, RawResponseHeader, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, RawResponseHeader, name) + +# Register Plugin in _CAPS: +_CAPS.Plugin_swigregister(Plugin) + +class RawResponseHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["timeSeconds"] = _CAPS.RawResponseHeader_timeSeconds_set - __swig_getmethods__["timeSeconds"] = _CAPS.RawResponseHeader_timeSeconds_get - if _newclass: - timeSeconds = _swig_property(_CAPS.RawResponseHeader_timeSeconds_get, _CAPS.RawResponseHeader_timeSeconds_set) - __swig_setmethods__["timeMicroSeconds"] = _CAPS.RawResponseHeader_timeMicroSeconds_set - __swig_getmethods__["timeMicroSeconds"] = _CAPS.RawResponseHeader_timeMicroSeconds_get - if _newclass: - timeMicroSeconds = _swig_property(_CAPS.RawResponseHeader_timeMicroSeconds_get, _CAPS.RawResponseHeader_timeMicroSeconds_set) + timeSeconds = property(_CAPS.RawResponseHeader_timeSeconds_get, _CAPS.RawResponseHeader_timeSeconds_set) + timeMicroSeconds = property(_CAPS.RawResponseHeader_timeMicroSeconds_get, _CAPS.RawResponseHeader_timeMicroSeconds_set) def get(self, buf): return _CAPS.RawResponseHeader_get(self, buf) @@ -1289,25 +930,14 @@ class RawResponseHeader(_object): return _CAPS.RawResponseHeader_dataSize(self) def __init__(self): - this = _CAPS.new_RawResponseHeader() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.RawResponseHeader_swiginit(self, _CAPS.new_RawResponseHeader()) __swig_destroy__ = _CAPS.delete_RawResponseHeader - __del__ = lambda self: None -RawResponseHeader_swigregister = _CAPS.RawResponseHeader_swigregister -RawResponseHeader_swigregister(RawResponseHeader) + +# Register RawResponseHeader in _CAPS: +_CAPS.RawResponseHeader_swigregister(RawResponseHeader) class RawDataRecord(DataRecord): - __swig_setmethods__ = {} - for _s in [DataRecord]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, RawDataRecord, name, value) - __swig_getmethods__ = {} - for _s in [DataRecord]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, RawDataRecord, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -1367,19 +997,12 @@ class RawDataRecord(DataRecord): def setBuffer(self, data, size): return _CAPS.RawDataRecord_setBuffer(self, data, size) __swig_destroy__ = _CAPS.delete_RawDataRecord - __del__ = lambda self: None -RawDataRecord_swigregister = _CAPS.RawDataRecord_swigregister -RawDataRecord_swigregister(RawDataRecord) + +# Register RawDataRecord in _CAPS: +_CAPS.RawDataRecord_swigregister(RawDataRecord) class FixedRawDataRecord(RawDataRecord): - __swig_setmethods__ = {} - for _s in [RawDataRecord]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, FixedRawDataRecord, name, value) - __swig_getmethods__ = {} - for _s in [RawDataRecord]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, FixedRawDataRecord, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -1403,20 +1026,14 @@ class FixedRawDataRecord(RawDataRecord): def packetType(self): return _CAPS.FixedRawDataRecord_packetType(self) __swig_destroy__ = _CAPS.delete_FixedRawDataRecord - __del__ = lambda self: None -FixedRawDataRecord_swigregister = _CAPS.FixedRawDataRecord_swigregister -FixedRawDataRecord_swigregister(FixedRawDataRecord) - -class ChunkHeader(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkHeader, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, ChunkHeader, name) + +# Register FixedRawDataRecord in _CAPS: +_CAPS.FixedRawDataRecord_swigregister(FixedRawDataRecord) + +class ChunkHeader(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["chunkSize"] = _CAPS.ChunkHeader_chunkSize_set - __swig_getmethods__["chunkSize"] = _CAPS.ChunkHeader_chunkSize_get - if _newclass: - chunkSize = _swig_property(_CAPS.ChunkHeader_chunkSize_get, _CAPS.ChunkHeader_chunkSize_set) + chunkSize = property(_CAPS.ChunkHeader_chunkSize_get, _CAPS.ChunkHeader_chunkSize_set) def setChunkType(self, type): return _CAPS.ChunkHeader_setChunkType(self, type) @@ -1443,29 +1060,18 @@ class ChunkHeader(_object): return _CAPS.ChunkHeader_put(self, output) def __init__(self): - this = _CAPS.new_ChunkHeader() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.ChunkHeader_swiginit(self, _CAPS.new_ChunkHeader()) __swig_destroy__ = _CAPS.delete_ChunkHeader - __del__ = lambda self: None -ChunkHeader_swigregister = _CAPS.ChunkHeader_swigregister -ChunkHeader_swigregister(ChunkHeader) - -class ChunkIterator(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, ChunkIterator, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, ChunkIterator, name) + +# Register ChunkHeader in _CAPS: +_CAPS.ChunkHeader_swigregister(ChunkHeader) + +class ChunkIterator(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_ChunkIterator(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.ChunkIterator_swiginit(self, _CAPS.new_ChunkIterator(*args)) def begin(self, *args): return _CAPS.ChunkIterator_begin(self, *args) @@ -1485,22 +1091,18 @@ class ChunkIterator(_object): def istream(self): return _CAPS.ChunkIterator_istream(self) __swig_destroy__ = _CAPS.delete_ChunkIterator - __del__ = lambda self: None -ChunkIterator_swigregister = _CAPS.ChunkIterator_swigregister -ChunkIterator_swigregister(ChunkIterator) + +# Register ChunkIterator in _CAPS: +_CAPS.ChunkIterator_swigregister(ChunkIterator) ChunkHeaderSize = cvar.ChunkHeaderSize -class Chunk(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Chunk, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Chunk, name) +class Chunk(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _CAPS.delete_Chunk - __del__ = lambda self: None def read(self, input, size): return _CAPS.Chunk_read(self, input, size) @@ -1516,23 +1118,14 @@ class Chunk(_object): def chunkSize(self): return _CAPS.Chunk_chunkSize(self) -Chunk_swigregister = _CAPS.Chunk_swigregister -Chunk_swigregister(Chunk) + +# Register Chunk in _CAPS: +_CAPS.Chunk_swigregister(Chunk) class HeadChunk(Chunk): - __swig_setmethods__ = {} - for _s in [Chunk]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, HeadChunk, name, value) - __swig_getmethods__ = {} - for _s in [Chunk]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, HeadChunk, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["data"] = _CAPS.HeadChunk_data_set - __swig_getmethods__["data"] = _CAPS.HeadChunk_data_get - if _newclass: - data = _swig_property(_CAPS.HeadChunk_data_get, _CAPS.HeadChunk_data_set) + data = property(_CAPS.HeadChunk_data_get, _CAPS.HeadChunk_data_set) def chunkSize(self): return _CAPS.HeadChunk_chunkSize(self) @@ -1544,38 +1137,19 @@ class HeadChunk(Chunk): return _CAPS.HeadChunk_put(self, output) def __init__(self): - this = _CAPS.new_HeadChunk() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.HeadChunk_swiginit(self, _CAPS.new_HeadChunk()) __swig_destroy__ = _CAPS.delete_HeadChunk - __del__ = lambda self: None -HeadChunk_swigregister = _CAPS.HeadChunk_swigregister -HeadChunk_swigregister(HeadChunk) - -class SID(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, SID, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, SID, name) + +# Register HeadChunk in _CAPS: +_CAPS.HeadChunk_swigregister(HeadChunk) + +class SID(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - __swig_setmethods__["networkCode"] = _CAPS.SID_networkCode_set - __swig_getmethods__["networkCode"] = _CAPS.SID_networkCode_get - if _newclass: - networkCode = _swig_property(_CAPS.SID_networkCode_get, _CAPS.SID_networkCode_set) - __swig_setmethods__["stationCode"] = _CAPS.SID_stationCode_set - __swig_getmethods__["stationCode"] = _CAPS.SID_stationCode_get - if _newclass: - stationCode = _swig_property(_CAPS.SID_stationCode_get, _CAPS.SID_stationCode_set) - __swig_setmethods__["locationCode"] = _CAPS.SID_locationCode_set - __swig_getmethods__["locationCode"] = _CAPS.SID_locationCode_get - if _newclass: - locationCode = _swig_property(_CAPS.SID_locationCode_get, _CAPS.SID_locationCode_set) - __swig_setmethods__["channelCode"] = _CAPS.SID_channelCode_set - __swig_getmethods__["channelCode"] = _CAPS.SID_channelCode_get - if _newclass: - channelCode = _swig_property(_CAPS.SID_channelCode_get, _CAPS.SID_channelCode_set) + networkCode = property(_CAPS.SID_networkCode_get, _CAPS.SID_networkCode_set) + stationCode = property(_CAPS.SID_stationCode_get, _CAPS.SID_stationCode_set) + locationCode = property(_CAPS.SID_locationCode_get, _CAPS.SID_locationCode_set) + channelCode = property(_CAPS.SID_channelCode_get, _CAPS.SID_channelCode_set) def __eq__(self, other): return _CAPS.SID___eq__(self, other) @@ -1587,25 +1161,14 @@ class SID(_object): return _CAPS.SID_toString(self) def __init__(self): - this = _CAPS.new_SID() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.SID_swiginit(self, _CAPS.new_SID()) __swig_destroy__ = _CAPS.delete_SID - __del__ = lambda self: None -SID_swigregister = _CAPS.SID_swigregister -SID_swigregister(SID) + +# Register SID in _CAPS: +_CAPS.SID_swigregister(SID) class SIDChunk(Chunk, SID): - __swig_setmethods__ = {} - for _s in [Chunk, SID]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, SIDChunk, name, value) - __swig_getmethods__ = {} - for _s in [Chunk, SID]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, SIDChunk, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def chunkSize(self): @@ -1618,25 +1181,14 @@ class SIDChunk(Chunk, SID): return _CAPS.SIDChunk_put(self, output) def __init__(self): - this = _CAPS.new_SIDChunk() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.SIDChunk_swiginit(self, _CAPS.new_SIDChunk()) __swig_destroy__ = _CAPS.delete_SIDChunk - __del__ = lambda self: None -SIDChunk_swigregister = _CAPS.SIDChunk_swigregister -SIDChunk_swigregister(SIDChunk) + +# Register SIDChunk in _CAPS: +_CAPS.SIDChunk_swigregister(SIDChunk) class RTCM2DataRecord(DataRecord): - __swig_setmethods__ = {} - for _s in [DataRecord]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, RTCM2DataRecord, name, value) - __swig_getmethods__ = {} - for _s in [DataRecord]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, RTCM2DataRecord, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") @@ -1684,15 +1236,12 @@ class RTCM2DataRecord(DataRecord): def packetType(self): return _CAPS.RTCM2DataRecord_packetType(self) __swig_destroy__ = _CAPS.delete_RTCM2DataRecord - __del__ = lambda self: None -RTCM2DataRecord_swigregister = _CAPS.RTCM2DataRecord_swigregister -RTCM2DataRecord_swigregister(RTCM2DataRecord) - -class Socket(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, Socket, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, Socket, name) + +# Register RTCM2DataRecord in _CAPS: +_CAPS.RTCM2DataRecord_swigregister(RTCM2DataRecord) + +class Socket(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr Success = _CAPS.Socket_Success Error = _CAPS.Socket_Error @@ -1711,17 +1260,12 @@ class Socket(_object): InvalidHostname = _CAPS.Socket_InvalidHostname def __init__(self): - this = _CAPS.new_Socket() - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.Socket_swiginit(self, _CAPS.new_Socket()) __swig_destroy__ = _CAPS.delete_Socket - __del__ = lambda self: None - if _newclass: - toString = staticmethod(_CAPS.Socket_toString) - else: - toString = _CAPS.Socket_toString + + @staticmethod + def toString(arg1): + return _CAPS.Socket_toString(arg1) def fd(self): return _CAPS.Socket_fd(self) @@ -1761,32 +1305,20 @@ class Socket(_object): def tx(self): return _CAPS.Socket_tx(self) -Socket_swigregister = _CAPS.Socket_swigregister -Socket_swigregister(Socket) -def Socket_toString(arg2): - return _CAPS.Socket_toString(arg2) -Socket_toString = _CAPS.Socket_toString +# Register Socket in _CAPS: +_CAPS.Socket_swigregister(Socket) + +def Socket_toString(arg1): + return _CAPS.Socket_toString(arg1) class SSLSocket(Socket): - __swig_setmethods__ = {} - for _s in [Socket]: - __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) - __setattr__ = lambda self, name, value: _swig_setattr(self, SSLSocket, name, value) - __swig_getmethods__ = {} - for _s in [Socket]: - __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) - __getattr__ = lambda self, name: _swig_getattr(self, SSLSocket, name) + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_SSLSocket(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.SSLSocket_swiginit(self, _CAPS.new_SSLSocket(*args)) __swig_destroy__ = _CAPS.delete_SSLSocket - __del__ = lambda self: None def write(self, data, len): return _CAPS.SSLSocket_write(self, data, len) @@ -1805,24 +1337,17 @@ class SSLSocket(Socket): def peerCertificate(self): return _CAPS.SSLSocket_peerCertificate(self) -SSLSocket_swigregister = _CAPS.SSLSocket_swigregister -SSLSocket_swigregister(SSLSocket) - -class charArray(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, charArray, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, charArray, name) + +# Register SSLSocket in _CAPS: +_CAPS.SSLSocket_swigregister(SSLSocket) + +class charArray(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, nelements): - this = _CAPS.new_charArray(nelements) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.charArray_swiginit(self, _CAPS.new_charArray(nelements)) __swig_destroy__ = _CAPS.delete_charArray - __del__ = lambda self: None def __getitem__(self, index): return _CAPS.charArray___getitem__(self, index) @@ -1832,30 +1357,23 @@ class charArray(_object): def cast(self): return _CAPS.charArray_cast(self) - if _newclass: - frompointer = staticmethod(_CAPS.charArray_frompointer) - else: - frompointer = _CAPS.charArray_frompointer -charArray_swigregister = _CAPS.charArray_swigregister -charArray_swigregister(charArray) + + @staticmethod + def frompointer(t): + return _CAPS.charArray_frompointer(t) + +# Register charArray in _CAPS: +_CAPS.charArray_swigregister(charArray) def charArray_frompointer(t): return _CAPS.charArray_frompointer(t) -charArray_frompointer = _CAPS.charArray_frompointer -class arraybuf(_object): - __swig_setmethods__ = {} - __setattr__ = lambda self, name, value: _swig_setattr(self, arraybuf, name, value) - __swig_getmethods__ = {} - __getattr__ = lambda self, name: _swig_getattr(self, arraybuf, name) +class arraybuf(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr def __init__(self, *args): - this = _CAPS.new_arraybuf(*args) - try: - self.this.append(this) - except __builtin__.Exception: - self.this = this + _CAPS.arraybuf_swiginit(self, _CAPS.new_arraybuf(*args)) def reset(self, buf, len): return _CAPS.arraybuf_reset(self, buf, len) @@ -1875,54 +1393,42 @@ class arraybuf(_object): def tellp(self): return _CAPS.arraybuf_tellp(self) __swig_destroy__ = _CAPS.delete_arraybuf - __del__ = lambda self: None -arraybuf_swigregister = _CAPS.arraybuf_swigregister -arraybuf_swigregister(arraybuf) + +# Register arraybuf in _CAPS: +_CAPS.arraybuf_swigregister(arraybuf) def splitAddress(host, port, address, default_port): return _CAPS.splitAddress(host, port, address, default_port) -splitAddress = _CAPS.splitAddress def tokenize(str, delim, len_source, len_tok): return _CAPS.tokenize(str, delim, len_source, len_tok) -tokenize = _CAPS.tokenize def trim(*args): return _CAPS.trim(*args) -trim = _CAPS.trim def timeToTimestamp(ts, t): return _CAPS.timeToTimestamp(ts, t) -timeToTimestamp = _CAPS.timeToTimestamp def str2int(*args): return _CAPS.str2int(*args) -str2int = _CAPS.str2int def timestampToTime(ts): return _CAPS.timestampToTime(ts) -timestampToTime = _CAPS.timestampToTime def samplesToTimeSpan(head, sampleCount): return _CAPS.samplesToTimeSpan(head, sampleCount) -samplesToTimeSpan = _CAPS.samplesToTimeSpan def timeSpanToSamples(head, span): return _CAPS.timeSpanToSamples(head, span) -timeSpanToSamples = _CAPS.timeSpanToSamples def timeSpanToSamplesCeil(head, span): return _CAPS.timeSpanToSamplesCeil(head, span) -timeSpanToSamplesCeil = _CAPS.timeSpanToSamplesCeil def timeSpanToSamplesFloor(head, span): return _CAPS.timeSpanToSamplesFloor(head, span) -timeSpanToSamplesFloor = _CAPS.timeSpanToSamplesFloor def dataTypeSize(dt): return _CAPS.dataTypeSize(dt) -dataTypeSize = _CAPS.dataTypeSize -# This file is compatible with both classic and new-style classes. diff --git a/libs/swig/gempa/CAPSPYTHON_wrap.cxx b/libs/swig/gempa/CAPSPYTHON_wrap.cxx index 636319a..0be38cb 100644 --- a/libs/swig/gempa/CAPSPYTHON_wrap.cxx +++ b/libs/swig/gempa/CAPSPYTHON_wrap.cxx @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 + * Version 4.0.2 * * 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 @@ -164,11 +164,16 @@ template T SwigValueInit() { #endif +#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 +#endif + #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) /* Use debug wrappers with the Python release dll */ # undef _DEBUG # include -# define _DEBUG +# define _DEBUG 1 #else # include #endif @@ -218,6 +223,7 @@ template T SwigValueInit() { /* 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 @@ -802,25 +808,31 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { SWIGINTERN char* SWIG_Python_str_AsChar(PyObject *str) { -#if PY_VERSION_HEX >= 0x03000000 - char *cstr; - char *newstr; - Py_ssize_t len; +#if PY_VERSION_HEX >= 0x03030000 + return (char *)PyUnicode_AsUTF8(str); +#elif PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; str = PyUnicode_AsUTF8String(str); - PyBytes_AsStringAndSize(str, &cstr, &len); - newstr = (char *) malloc(len+1); - memcpy(newstr, cstr, len+1); - Py_XDECREF(str); + if (str) { + char *cstr; + Py_ssize_t len; + if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) { + newstr = (char *) malloc(len+1); + if (newstr) + memcpy(newstr, cstr, len+1); + } + Py_XDECREF(str); + } return newstr; #else return PyString_AsString(str); #endif } -#if PY_VERSION_HEX >= 0x03000000 -# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000 +# define SWIG_Python_str_DelForPy3(x) #else -# define SWIG_Python_str_DelForPy3(x) +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) #endif @@ -834,144 +846,14 @@ SWIG_Python_str_FromChar(const char *c) #endif } -/* 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 - -#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); -} -#endif - #ifndef PyObject_DEL # define PyObject_DEL PyObject_Del #endif -/* 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 -#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 -#endif - -/* PySequence_Size for old Pythons */ -#if PY_VERSION_HEX < 0x02000000 -# ifndef PySequence_Size -# define PySequence_Size PySequence_Length -# endif -#endif - -/* PyBool_FromLong for old Pythons */ -#if PY_VERSION_HEX < 0x02030000 -static -PyObject *PyBool_FromLong(long ok) -{ - PyObject *result = ok ? Py_True : Py_False; - Py_INCREF(result); - return result; -} -#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 -typedef inquiry lenfunc; -typedef intargfunc ssizeargfunc; -typedef intintargfunc ssizessizeargfunc; -typedef intobjargproc ssizeobjargproc; -typedef intintobjargproc ssizessizeobjargproc; -typedef getreadbufferproc readbufferproc; -typedef getwritebufferproc writebufferproc; -typedef getsegcountproc segcountproc; -typedef getcharbufferproc charbufferproc; -static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc)) -{ - long result = 0; - PyObject *i = PyNumber_Int(x); - if (i) { - result = PyInt_AsLong(i); - Py_DECREF(i); - } - return result; -} -#endif - -#if PY_VERSION_HEX < 0x02050000 -#define PyInt_FromSize_t(x) PyInt_FromLong((long)x) -#endif - -#if PY_VERSION_HEX < 0x02040000 -#define Py_VISIT(op) \ - do { \ - if (op) { \ - int vret = visit((op), arg); \ - if (vret) \ - return vret; \ - } \ - } while (0) -#endif - -#if PY_VERSION_HEX < 0x02030000 -typedef struct { - PyTypeObject type; - PyNumberMethods as_number; - PyMappingMethods as_mapping; - PySequenceMethods as_sequence; - PyBufferProcs as_buffer; - PyObject *name, *slots; -} PyHeapTypeObject; -#endif - -#if PY_VERSION_HEX < 0x02030000 -typedef destructor freefunc; -#endif - -#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \ - (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \ - (PY_MAJOR_VERSION > 3)) +// 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 ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) -#endif +# 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) @@ -1034,14 +916,17 @@ 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) { - char *tmp; 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", tmp = SWIG_Python_str_AsChar(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); @@ -1050,6 +935,37 @@ 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) # undef SWIG_PYTHON_THREADS @@ -1057,9 +973,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 @@ -1136,30 +1050,13 @@ extern "C" { /* Constant information structure */ typedef struct swig_const_info { int type; - char *name; + const char *name; long lvalue; double dvalue; void *pvalue; swig_type_info **ptype; } swig_const_info; - -/* ----------------------------------------------------------------------------- - * Wrapper of PyInstanceMethod_New() used in Python 3 - * It is exported to the generated module, used for -fastproxy - * ----------------------------------------------------------------------------- */ -#if PY_VERSION_HEX >= 0x03000000 -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) -{ - return PyInstanceMethod_New(func); -} -#else -SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func)) -{ - return NULL; -} -#endif - #ifdef __cplusplus } #endif @@ -1174,6 +1071,14 @@ SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), * * ----------------------------------------------------------------------------- */ +#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 */ @@ -1257,11 +1162,7 @@ SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { -#if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); -#else PyDict_SetItemString(d, name, obj); -#endif Py_DECREF(obj); if (public_interface) SwigPyBuiltin_AddPublicSymbol(public_interface, name); @@ -1271,11 +1172,7 @@ SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *nam SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { -#if PY_VERSION_HEX < 0x02030000 - PyDict_SetItemString(d, (char *)name, obj); -#else PyDict_SetItemString(d, name, obj); -#endif Py_DECREF(obj); } @@ -1285,7 +1182,6 @@ SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *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) { @@ -1301,29 +1197,6 @@ 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 */ @@ -1374,12 +1247,21 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi } } +SWIGINTERN int +SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) { + int no_kwargs = 1; + if (kwargs) { + assert(PyDict_Check(kwargs)); + if (PyDict_Size(kwargs) > 0) { + PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name); + no_kwargs = 0; + } + } + return no_kwargs; +} + /* 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 /* Helper for static pointer initialization for both C and C++ code, for example @@ -1408,35 +1290,6 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi extern "C" { #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 */ SWIGRUNTIMEINLINE PyObject * @@ -1463,7 +1316,10 @@ SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty) { SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; - return data ? data->implicitconv : 0; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; } SWIGRUNTIMEINLINE PyObject * @@ -1490,11 +1346,7 @@ SwigPyClientData_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); @@ -1505,7 +1357,7 @@ SwigPyClientData_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; @@ -1514,11 +1366,7 @@ SwigPyClientData_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; } @@ -1606,20 +1454,12 @@ SwigPyObject_hex(SwigPyObject *v) } SWIGRUNTIME PyObject * -#ifdef METH_NOARGS SwigPyObject_repr(SwigPyObject *v) -#else -SwigPyObject_repr(SwigPyObject *v, PyObject *args) -#endif { const char *name = SWIG_TypePrettyName(v->ty); PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); if (v->next) { -# ifdef METH_NOARGS PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); -# else - PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args); -# endif # if PY_VERSION_HEX >= 0x03000000 PyObject *joined = PyUnicode_Concat(repr, nrep); Py_DecRef(repr); @@ -1632,6 +1472,14 @@ SwigPyObject_repr(SwigPyObject *v, PyObject *args) return repr; } +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) { @@ -1705,14 +1553,14 @@ SwigPyObject_dealloc(PyObject *v) PyObject *res; /* PyObject_CallFunction() has the potential to silently drop - the active active exception. In cases of unnamed temporary + 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 *val = NULL, *type = NULL, *tb = NULL; - PyErr_Fetch(&val, &type, &tb); + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); if (data->delargs) { /* we need to create a temporary object to carry the destroy operation */ @@ -1727,7 +1575,7 @@ SwigPyObject_dealloc(PyObject *v) if (!res) PyErr_WriteUnraisable(destroy); - PyErr_Restore(val, type, tb); + PyErr_Restore(type, value, traceback); Py_XDECREF(res); } @@ -1746,11 +1594,6 @@ SWIGRUNTIME PyObject* SwigPyObject_append(PyObject* v, PyObject* next) { SwigPyObject *sobj = (SwigPyObject *) v; -#ifndef METH_O - PyObject *tmp = 0; - if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; - next = tmp; -#endif if (!SwigPyObject_Check(next)) { PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); return NULL; @@ -1761,11 +1604,7 @@ SwigPyObject_append(PyObject* v, PyObject* next) } SWIGRUNTIME PyObject* -#ifdef METH_NOARGS -SwigPyObject_next(PyObject* v) -#else SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif { SwigPyObject *sobj = (SwigPyObject *) v; if (sobj->next) { @@ -1777,11 +1616,7 @@ SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) } SWIGINTERN PyObject* -#ifdef METH_NOARGS -SwigPyObject_disown(PyObject *v) -#else SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif { SwigPyObject *sobj = (SwigPyObject *)v; sobj->own = 0; @@ -1789,11 +1624,7 @@ SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) } SWIGINTERN PyObject* -#ifdef METH_NOARGS -SwigPyObject_acquire(PyObject *v) -#else SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) -#endif { SwigPyObject *sobj = (SwigPyObject *)v; sobj->own = SWIG_POINTER_OWN; @@ -1804,70 +1635,32 @@ SWIGINTERN PyObject* SwigPyObject_own(PyObject *v, PyObject *args) { PyObject *val = 0; -#if (PY_VERSION_HEX < 0x02020000) - if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) -#elif (PY_VERSION_HEX < 0x02050000) - if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) -#else - if (!PyArg_UnpackTuple(args, "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 - { - SwigPyObject *sobj = (SwigPyObject *)v; - PyObject *obj = PyBool_FromLong(sobj->own); - if (val) { -#ifdef METH_NOARGS - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v); - } else { - SwigPyObject_disown(v); - } -#else - if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); - } else { - SwigPyObject_disown(v,args); - } -#endif - } - return obj; - } + return obj; + } } -#ifdef METH_O static PyMethodDef swigobject_methods[] = { - {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_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)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, - {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"}, - {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, - {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, - {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, - {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"}, - {0, 0, 0, 0} -}; -#endif - -#if PY_VERSION_HEX < 0x02020000 -SWIGINTERN PyObject * -SwigPyObject_getattr(SwigPyObject *sobj,char *name) -{ - return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); -} -#endif SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void) { @@ -1912,12 +1705,8 @@ SwigPyObject_TypeOnce(void) { 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 */ -#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ +#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 }; @@ -1931,16 +1720,12 @@ SwigPyObject_TypeOnce(void) { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - (char *)"SwigPyObject", /* tp_name */ + "SwigPyObject", /* tp_name */ sizeof(SwigPyObject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyObject_dealloc, /* tp_dealloc */ 0, /* tp_print */ -#if PY_VERSION_HEX < 0x02020000 - (getattrfunc)SwigPyObject_getattr, /* tp_getattr */ -#else (getattrfunc)0, /* tp_getattr */ -#endif (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 */ @@ -1963,7 +1748,6 @@ SwigPyObject_TypeOnce(void) { 0, /* tp_clear */ (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ swigobject_methods, /* tp_methods */ @@ -1984,34 +1768,29 @@ SwigPyObject_TypeOnce(void) { 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ -#endif -#if PY_VERSION_HEX >= 0x02060000 0, /* tp_version_tag */ -#endif #if PY_VERSION_HEX >= 0x03040000 0, /* tp_finalize */ #endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 0, /* tp_prev */ -#endif 0 /* tp_next */ #endif }; swigpyobject_type = tmp; type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - swigpyobject_type.ob_type = &PyType_Type; -#else if (PyType_Ready(&swigpyobject_type) < 0) return NULL; -#endif } return &swigpyobject_type; } @@ -2040,20 +1819,6 @@ typedef struct { size_t size; } SwigPyPacked; -SWIGRUNTIME int -SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) -{ - char result[SWIG_BUFFER_SIZE]; - fputs("pack, v->size, 0, sizeof(result))) { - fputs("at ", fp); - fputs(result, fp); - } - fputs(v->ty->name,fp); - fputs(">", fp); - return 0; -} - SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v) { @@ -2082,7 +1847,7 @@ 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* SwigPyPacked_TypeOnce(void); @@ -2122,11 +1887,11 @@ SwigPyPacked_TypeOnce(void) { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - (char *)"SwigPyPacked", /* tp_name */ + "SwigPyPacked", /* tp_name */ sizeof(SwigPyPacked), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ - (printfunc)SwigPyPacked_print, /* tp_print */ + 0, /* tp_print */ (getattrfunc)0, /* tp_getattr */ (setattrfunc)0, /* tp_setattr */ #if PY_VERSION_HEX>=0x03000000 @@ -2150,7 +1915,6 @@ SwigPyPacked_TypeOnce(void) { 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ -#if PY_VERSION_HEX >= 0x02020000 0, /* tp_iter */ 0, /* tp_iternext */ 0, /* tp_methods */ @@ -2171,34 +1935,29 @@ SwigPyPacked_TypeOnce(void) { 0, /* tp_cache */ 0, /* tp_subclasses */ 0, /* tp_weaklist */ -#endif -#if PY_VERSION_HEX >= 0x02030000 0, /* tp_del */ -#endif -#if PY_VERSION_HEX >= 0x02060000 0, /* tp_version_tag */ -#endif #if PY_VERSION_HEX >= 0x03040000 0, /* tp_finalize */ #endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 0, /* tp_prev */ -#endif 0 /* tp_next */ #endif }; swigpypacked_type = tmp; type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - swigpypacked_type.ob_type = &PyType_Type; -#else if (PyType_Ready(&swigpypacked_type) < 0) return NULL; -#endif } return &swigpypacked_type; } @@ -2239,20 +1998,14 @@ SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) * pointers/data manipulation * ----------------------------------------------------------------------------- */ -SWIGRUNTIMEINLINE PyObject * -_SWIG_This(void) -{ - return SWIG_Python_str_FromChar("this"); -} - -static PyObject *swig_this = NULL; +static PyObject *Swig_This_global = NULL; SWIGRUNTIME PyObject * SWIG_This(void) { - if (swig_this == NULL) - 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 */ @@ -2284,7 +2037,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj) obj = 0; -#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) if (PyInstance_Check(pyobj)) { obj = _PyInstance_Lookup(pyobj, SWIG_This()); } else { @@ -2354,7 +2107,7 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int if (obj == Py_None && !implicit_conv) { if (ptr) *ptr = 0; - return SWIG_OK; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; } res = SWIG_ERROR; @@ -2434,13 +2187,13 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int } } } - } - if (!SWIG_IsOK(res) && obj == Py_None) { - if (ptr) - *ptr = 0; - if (PyErr_Occurred()) - PyErr_Clear(); - res = SWIG_OK; + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } } } return res; @@ -2454,31 +2207,28 @@ 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) desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; - if (!desc) + 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; - } + 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) { @@ -2506,7 +2256,6 @@ SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *t SWIGRUNTIME PyObject* SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) { -#if (PY_VERSION_HEX >= 0x02020000) PyObject *inst = 0; PyObject *newraw = data->newraw; if (newraw) { @@ -2523,16 +2272,30 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) } } #else - PyObject *key = SWIG_This(); - PyObject_SetAttr(inst, key, swig_this); + if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { + Py_DECREF(inst); + inst = 0; + } #endif } } else { #if PY_VERSION_HEX >= 0x03000000 - inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None); - if (inst) { - PyObject_SetAttr(inst, SWIG_This(), swig_this); - Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + 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) { + if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { + Py_DECREF(inst); + inst = 0; + } else { + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + } + Py_DECREF(empty_args); } #else PyObject *dict = PyDict_New(); @@ -2544,59 +2307,23 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) #endif } return inst; -#else -#if (PY_VERSION_HEX >= 0x02010000) - PyObject *inst = 0; - PyObject *dict = PyDict_New(); - if (dict) { - 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 +SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) { - PyObject *dict; -#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) - PyObject **dictptr = _PyObject_GetDictPtr(inst); - if (dictptr != NULL) { - dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - } - PyDict_SetItem(dict, SWIG_This(), swig_this); - return; - } +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + return PyDict_SetItem(dict, SWIG_This(), swig_this); + } #endif - dict = PyObject_GetAttrString(inst, (char*)"__dict__"); - PyDict_SetItem(dict, SWIG_This(), swig_this); - Py_DECREF(dict); + return PyObject_SetAttr(inst, SWIG_This(), swig_this); } @@ -2610,7 +2337,8 @@ SWIG_Python_InitShadowInstance(PyObject *args) { if (sthis) { SwigPyObject_append((PyObject*) sthis, obj[1]); } else { - SWIG_Python_SetSwigThis(obj[0], obj[1]); + if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0) + return NULL; } return SWIG_Py_Void(); } @@ -2693,12 +2421,7 @@ SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { #ifdef SWIG_LINK_RUNTIME type_pointer = SWIG_ReturnGlobalTypeList((void *)0); #else -# ifdef SWIGPY_USE_CAPSULE type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); -# else - type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, - (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); -# endif if (PyErr_Occurred()) { PyErr_Clear(); type_pointer = (void *)0; @@ -2708,48 +2431,10 @@ SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { 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 -#ifdef SWIGPY_USE_CAPSULE SWIG_Python_DestroyModule(PyObject *obj) -#else -SWIG_Python_DestroyModule(void *vptr) -#endif { -#ifdef SWIGPY_USE_CAPSULE swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); -#else - swig_module_info *swig_module = (swig_module_info *) vptr; -#endif swig_type_info **types = swig_module->types; size_t i; for (i =0; i < swig_module->size; ++i) { @@ -2760,33 +2445,24 @@ SWIG_Python_DestroyModule(void *vptr) } } Py_DECREF(SWIG_This()); - swig_this = NULL; + Swig_This_global = NULL; } SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module) { #if PY_VERSION_HEX >= 0x03000000 /* Add a dummy module object into sys.modules */ - PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION); + 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((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); #endif -#ifdef SWIGPY_USE_CAPSULE PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); if (pointer && module) { - PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); - } else { - Py_XDECREF(pointer); - } -#else - PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, 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); } -#endif } /* The python cached type query */ @@ -2804,20 +2480,12 @@ SWIG_Python_TypeQuery(const char *type) PyObject *obj = PyDict_GetItem(cache, key); swig_type_info *descriptor; if (obj) { -#ifdef SWIGPY_USE_CAPSULE descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); -#else - descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); -#endif } else { swig_module_info *swig_module = SWIG_GetModule(0); descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { -#ifdef SWIGPY_USE_CAPSULE obj = PyCapsule_New((void*) descriptor, NULL, NULL); -#else - obj = PyCObject_FromVoidPtr(descriptor, NULL); -#endif PyDict_SetItem(cache, key, obj); Py_DECREF(obj); } @@ -2842,14 +2510,15 @@ SWIG_Python_AddErrMesg(const char* mesg, int infront) PyObject *traceback = 0; PyErr_Fetch(&type, &value, &traceback); if (value) { - char *tmp; 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, tmp = SWIG_Python_str_AsChar(old_str)); + PyErr_Format(type, "%s %s", mesg, errmesg); } else { - PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg); + PyErr_Format(type, "%s %s", errmesg, mesg); } SWIG_Python_str_DelForPy3(tmp); Py_DECREF(old_str); @@ -2975,6 +2644,8 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { 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); @@ -3001,6 +2672,21 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { +#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 + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) @@ -3050,8 +2736,8 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIGTYPE_p_Gempa__CAPS__TimeStamp swig_types[41] #define SWIGTYPE_p_Gempa__CAPS__UOM swig_types[42] #define SWIGTYPE_p_Gempa__CAPS__arraybuf swig_types[43] -#define SWIGTYPE_p_INT_TIME swig_types[44] -#define SWIGTYPE_p_PacketAckFunc swig_types[45] +#define SWIGTYPE_p_PacketAckFunc swig_types[44] +#define SWIGTYPE_p_PacketBuffer swig_types[45] #define SWIGTYPE_p_SSL_CTX swig_types[46] #define SWIGTYPE_p_StreamStates swig_types[47] #define SWIGTYPE_p_X509 swig_types[48] @@ -3073,20 +2759,20 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { #define SWIGTYPE_p_pos_type swig_types[64] #define SWIGTYPE_p_short swig_types[65] #define SWIGTYPE_p_signed_char swig_types[66] -#define SWIGTYPE_p_std__ios_base__openmode swig_types[67] -#define SWIGTYPE_p_std__ios_base__seekdir swig_types[68] -#define SWIGTYPE_p_std__istream swig_types[69] -#define SWIGTYPE_p_std__mapT_std__string_Gempa__CAPS__Plugin__StreamState_t swig_types[70] -#define SWIGTYPE_p_std__ostream swig_types[71] -#define SWIGTYPE_p_std__streambuf swig_types[72] -#define SWIGTYPE_p_std__streambuf__off_type swig_types[73] -#define SWIGTYPE_p_std__streambuf__pos_type swig_types[74] -#define SWIGTYPE_p_std__streampos swig_types[75] -#define SWIGTYPE_p_std__streamsize swig_types[76] -#define SWIGTYPE_p_std__string swig_types[77] -#define SWIGTYPE_p_std__vectorT_char_t swig_types[78] -#define SWIGTYPE_p_timeval swig_types[79] -#define SWIGTYPE_p_uint swig_types[80] +#define SWIGTYPE_p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t swig_types[67] +#define SWIGTYPE_p_std__ios_base__openmode swig_types[68] +#define SWIGTYPE_p_std__ios_base__seekdir swig_types[69] +#define SWIGTYPE_p_std__istream swig_types[70] +#define SWIGTYPE_p_std__mapT_std__string_Gempa__CAPS__Plugin__StreamState_t swig_types[71] +#define SWIGTYPE_p_std__ostream swig_types[72] +#define SWIGTYPE_p_std__streambuf swig_types[73] +#define SWIGTYPE_p_std__streambuf__off_type swig_types[74] +#define SWIGTYPE_p_std__streambuf__pos_type swig_types[75] +#define SWIGTYPE_p_std__streampos swig_types[76] +#define SWIGTYPE_p_std__streamsize swig_types[77] +#define SWIGTYPE_p_std__string swig_types[78] +#define SWIGTYPE_p_std__vectorT_char_t swig_types[79] +#define SWIGTYPE_p_timeval swig_types[80] #define SWIGTYPE_p_unsigned_char swig_types[81] #define SWIGTYPE_p_unsigned_int swig_types[82] #define SWIGTYPE_p_unsigned_long_long swig_types[83] @@ -3098,11 +2784,10 @@ static swig_module_info swig_module = {swig_types, 85, 0, 0, 0, 0}; /* -------- 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):= _CAPS.so @@ -3116,7 +2801,7 @@ static swig_module_info swig_module = {swig_types, 85, 0, 0, 0, 0}; #endif #define SWIG_name "_CAPS" -#define SWIGVERSION 0x030012 +#define SWIGVERSION 0x040002 #define SWIG_VERSION SWIGVERSION @@ -3423,6 +3108,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #endif { char *cstr; Py_ssize_t len; + int ret = SWIG_OK; #if PY_VERSION_HEX>=0x03000000 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) if (!alloc && cptr) { @@ -3433,29 +3119,20 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) return SWIG_RuntimeError; } obj = PyUnicode_AsUTF8String(obj); - if(alloc) *alloc = SWIG_NEWOBJ; + if (!obj) + return SWIG_TypeError; + if (alloc) + *alloc = SWIG_NEWOBJ; #endif - PyBytes_AsStringAndSize(obj, &cstr, &len); + if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1) + return SWIG_TypeError; #else - PyString_AsStringAndSize(obj, &cstr, &len); + if (PyString_AsStringAndSize(obj, &cstr, &len) == -1) + return SWIG_TypeError; #endif 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) -#else - if (*alloc == SWIG_NEWOBJ) -#endif - { + if (*alloc == SWIG_NEWOBJ) { *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1))); *alloc = SWIG_NEWOBJ; } else { @@ -3471,6 +3148,8 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #endif #else *cptr = SWIG_Python_str_AsChar(obj); + if (!*cptr) + ret = SWIG_TypeError; #endif } } @@ -3478,7 +3157,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR) Py_XDECREF(obj); #endif - return SWIG_OK; + return ret; } else { #if defined(SWIG_PYTHON_2_UNICODE) #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) @@ -3491,6 +3170,8 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) 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; @@ -3538,11 +3219,7 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size) #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); #else -#if PY_VERSION_HEX >= 0x03010000 return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); -#else - return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#endif #endif #else return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); @@ -4058,11 +3735,11 @@ SWIGINTERN charArray *charArray_frompointer(char *t){ #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_TimeSpan")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::TimeSpan *)new Gempa::CAPS::TimeSpan(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -4071,16 +3748,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; timeval *arg1 = (timeval *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_TimeSpan",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_timeval, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_timeval, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeSpan" "', argument " "1"" of type '" "timeval *""'"); } @@ -4093,16 +3769,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; timeval *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_TimeSpan",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_timeval, 0 | 0); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_timeval, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeSpan" "', argument " "1"" of type '" "timeval const &""'"); } @@ -4118,16 +3793,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double arg1 ; double val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_TimeSpan",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_double(obj0, &val1); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', argument " "1"" of type '" "double""'"); } @@ -4140,7 +3814,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; long arg1 ; long arg2 ; @@ -4148,17 +3822,15 @@ SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int ecode1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:new_TimeSpan",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_long(obj0, &val1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', argument " "1"" of type '" "long""'"); } arg1 = static_cast< long >(val1); - ecode2 = SWIG_AsVal_long(obj1, &val2); + ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', argument " "2"" of type '" "long""'"); } @@ -4171,16 +3843,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TimeSpan__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_TimeSpan",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimeSpan" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4201,15 +3872,11 @@ SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeSpan", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_TimeSpan__SWIG_0(self, args); + return _wrap_new_TimeSpan__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -4217,23 +3884,23 @@ SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_timeval, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_TimeSpan__SWIG_1(self, args); + return _wrap_new_TimeSpan__SWIG_1(self, argc, argv); } } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_timeval, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_timeval, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_TimeSpan__SWIG_2(self, args); + return _wrap_new_TimeSpan__SWIG_2(self, argc, argv); } } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_TimeSpan__SWIG_5(self, args); + return _wrap_new_TimeSpan__SWIG_5(self, argc, argv); } } if (argc == 1) { @@ -4243,7 +3910,7 @@ SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeSpan__SWIG_3(self, args); + return _wrap_new_TimeSpan__SWIG_3(self, argc, argv); } } if (argc == 2) { @@ -4258,13 +3925,13 @@ SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeSpan__SWIG_4(self, args); + return _wrap_new_TimeSpan__SWIG_4(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeSpan'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeSpan'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::TimeSpan::TimeSpan()\n" " Gempa::CAPS::TimeSpan::TimeSpan(timeval *)\n" @@ -4284,17 +3951,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___eq__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4306,7 +3972,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4318,17 +3986,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4340,7 +4007,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4352,17 +4021,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___lt__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___lt__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4374,7 +4042,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4386,17 +4056,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___le__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___le__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4408,7 +4077,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4420,17 +4091,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___gt__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___gt__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4442,7 +4112,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4454,17 +4126,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___ge__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___ge__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4476,7 +4147,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObj resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4488,17 +4161,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___add__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___add__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4510,7 +4182,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyOb resultobj = SWIG_NewPointerObj((new Gempa::CAPS::TimeSpan(static_cast< const Gempa::CAPS::TimeSpan& >(result))), SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4522,17 +4196,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan result; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___sub__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4544,7 +4217,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyOb resultobj = SWIG_NewPointerObj((new Gempa::CAPS::TimeSpan(static_cast< const Gempa::CAPS::TimeSpan& >(result))), SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -4556,17 +4231,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___iadd__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___iadd__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4590,17 +4264,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan___isub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan___isub__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -4621,11 +4294,12 @@ SWIGINTERN PyObject *_wrap_TimeSpan_abs(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::TimeSpan result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeSpan_abs",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_abs" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } @@ -4643,11 +4317,12 @@ SWIGINTERN PyObject *_wrap_TimeSpan_seconds(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; long result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeSpan_seconds",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_seconds" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } @@ -4665,11 +4340,12 @@ SWIGINTERN PyObject *_wrap_TimeSpan_microseconds(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; long result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeSpan_microseconds",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_microseconds" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } @@ -4687,11 +4363,12 @@ SWIGINTERN PyObject *_wrap_TimeSpan_length(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; double result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeSpan_length",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_length" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } @@ -4712,17 +4389,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan_set(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - ecode2 = SWIG_AsVal_long(obj1, &val2); + ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_set" "', argument " "2"" of type '" "long""'"); } @@ -4743,17 +4419,16 @@ SWIGINTERN PyObject *_wrap_TimeSpan_setUSecs(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan_setUSecs",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeSpan_setUSecs", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_setUSecs" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - ecode2 = SWIG_AsVal_long(obj1, &val2); + ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_setUSecs" "', argument " "2"" of type '" "long""'"); } @@ -4766,7 +4441,7 @@ fail: } -SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; int *arg2 = (int *) 0 ; @@ -4783,34 +4458,29 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_0(PyObject *SWIGUNUSEDPARM int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeSpan_elapsedTime",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_elapsedTime" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - 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 '" "TimeSpan_elapsedTime" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "TimeSpan_elapsedTime" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeSpan_elapsedTime" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeSpan_elapsedTime" "', argument " "5"" of type '" "int *""'"); } @@ -4823,7 +4493,7 @@ fail: } -SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; int *arg2 = (int *) 0 ; @@ -4837,28 +4507,24 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_1(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeSpan_elapsedTime",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_elapsedTime" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - 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 '" "TimeSpan_elapsedTime" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "TimeSpan_elapsedTime" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeSpan_elapsedTime" "', argument " "4"" of type '" "int *""'"); } @@ -4871,7 +4537,7 @@ fail: } -SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; int *arg2 = (int *) 0 ; @@ -4882,22 +4548,19 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_2(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:TimeSpan_elapsedTime",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_elapsedTime" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - 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 '" "TimeSpan_elapsedTime" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "TimeSpan_elapsedTime" "', argument " "3"" of type '" "int *""'"); } @@ -4910,7 +4573,7 @@ fail: } -SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; int *arg2 = (int *) 0 ; @@ -4918,16 +4581,14 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime__SWIG_3(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeSpan_elapsedTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_elapsedTime" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeSpan * >(argp1); - 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 '" "TimeSpan_elapsedTime" "', argument " "2"" of type '" "int *""'"); } @@ -4945,13 +4606,9 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) PyObject *argv[6] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "TimeSpan_elapsedTime", 0, 5, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; @@ -4962,7 +4619,7 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TimeSpan_elapsedTime__SWIG_3(self, args); + return _wrap_TimeSpan_elapsedTime__SWIG_3(self, argc, argv); } } } @@ -4980,7 +4637,7 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TimeSpan_elapsedTime__SWIG_2(self, args); + return _wrap_TimeSpan_elapsedTime__SWIG_2(self, argc, argv); } } } @@ -5003,7 +4660,7 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TimeSpan_elapsedTime__SWIG_1(self, args); + return _wrap_TimeSpan_elapsedTime__SWIG_1(self, argc, argv); } } } @@ -5031,7 +4688,7 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TimeSpan_elapsedTime__SWIG_0(self, args); + return _wrap_TimeSpan_elapsedTime__SWIG_0(self, argc, argv); } } } @@ -5040,7 +4697,7 @@ SWIGINTERN PyObject *_wrap_TimeSpan_elapsedTime(PyObject *self, PyObject *args) } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeSpan_elapsedTime'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TimeSpan_elapsedTime'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::TimeSpan::elapsedTime(int *,int *,int *,int *) const\n" " Gempa::CAPS::TimeSpan::elapsedTime(int *,int *,int *) const\n" @@ -5055,10 +4712,11 @@ SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::TimeSpan *arg1 = (Gempa::CAPS::TimeSpan *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeSpan",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan *""'"); } @@ -5073,11 +4731,15 @@ fail: SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN int Swig_var_Time_Null_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable Time_Null is read-only."); return 1; @@ -5092,11 +4754,11 @@ SWIGINTERN PyObject *Swig_var_Time_Null_get(void) { } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Time")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::Time *)new Gempa::CAPS::Time(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -5105,7 +4767,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; long arg1 ; long arg2 ; @@ -5113,17 +4775,15 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:new_Time",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_long(obj0, &val1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_long(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "long""'"); } arg1 = static_cast< long >(val1); - ecode2 = SWIG_AsVal_long(obj1, &val2); + ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Time" "', argument " "2"" of type '" "long""'"); } @@ -5136,16 +4796,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::TimeSpan *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Time",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Time" "', argument " "1"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -5161,16 +4820,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; timeval *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Time",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_timeval, 0 | 0); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_timeval, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Time" "', argument " "1"" of type '" "timeval const &""'"); } @@ -5186,16 +4844,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; timeval *arg1 = (timeval *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Time",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_timeval, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_timeval, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Time" "', argument " "1"" of type '" "timeval *""'"); } @@ -5208,16 +4865,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double arg1 ; double val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Time",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_double(obj0, &val1); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "double""'"); } @@ -5230,7 +4886,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5253,47 +4909,40 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode6 = 0 ; int val7 ; int ecode7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Time",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_Time" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "new_Time" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "new_Time" "', argument " "4"" of type '" "int""'"); } arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Time" "', argument " "5"" of type '" "int""'"); } arg5 = static_cast< int >(val5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Time" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Time" "', argument " "7"" of type '" "int""'"); } @@ -5306,7 +4955,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5326,41 +4975,35 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Time",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_Time" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "new_Time" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "new_Time" "', argument " "4"" of type '" "int""'"); } arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Time" "', argument " "5"" of type '" "int""'"); } arg5 = static_cast< int >(val5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Time" "', argument " "6"" of type '" "int""'"); } @@ -5373,7 +5016,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5390,35 +5033,30 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Time",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_Time" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "new_Time" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "new_Time" "', argument " "4"" of type '" "int""'"); } arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Time" "', argument " "5"" of type '" "int""'"); } @@ -5431,7 +5069,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5445,29 +5083,25 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Time",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_Time" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "new_Time" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "new_Time" "', argument " "4"" of type '" "int""'"); } @@ -5480,7 +5114,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5491,23 +5125,20 @@ SWIGINTERN PyObject *_wrap_new_Time__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyO int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:new_Time",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Time" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_Time" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "new_Time" "', argument " "3"" of type '" "int""'"); } @@ -5520,16 +5151,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Time__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Time__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Time",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Time" "', argument " "1"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -5550,30 +5180,26 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { PyObject *argv[8] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Time", 0, 7, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_Time__SWIG_0(self, args); + return _wrap_new_Time__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Time__SWIG_11(self, args); + return _wrap_new_Time__SWIG_11(self, argc, argv); } } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_timeval, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_timeval, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Time__SWIG_3(self, args); + return _wrap_new_Time__SWIG_3(self, argc, argv); } } if (argc == 1) { @@ -5582,15 +5208,15 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_timeval, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Time__SWIG_4(self, args); + return _wrap_new_Time__SWIG_4(self, argc, argv); } } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Time__SWIG_2(self, args); + return _wrap_new_Time__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -5600,7 +5226,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_5(self, args); + return _wrap_new_Time__SWIG_5(self, argc, argv); } } if (argc == 2) { @@ -5615,7 +5241,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_1(self, args); + return _wrap_new_Time__SWIG_1(self, argc, argv); } } } @@ -5636,7 +5262,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_10(self, args); + return _wrap_new_Time__SWIG_10(self, argc, argv); } } } @@ -5663,7 +5289,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_9(self, args); + return _wrap_new_Time__SWIG_9(self, argc, argv); } } } @@ -5696,7 +5322,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_8(self, args); + return _wrap_new_Time__SWIG_8(self, argc, argv); } } } @@ -5735,7 +5361,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_7(self, args); + return _wrap_new_Time__SWIG_7(self, argc, argv); } } } @@ -5780,7 +5406,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Time__SWIG_6(self, args); + return _wrap_new_Time__SWIG_6(self, argc, argv); } } } @@ -5791,7 +5417,7 @@ SWIGINTERN PyObject *_wrap_new_Time(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Time'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Time'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Time::Time()\n" " Gempa::CAPS::Time::Time(long,long)\n" @@ -5814,11 +5440,12 @@ SWIGINTERN PyObject *_wrap_Time___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Time___nonzero__",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___nonzero__" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } @@ -5839,17 +5466,16 @@ SWIGINTERN PyObject *_wrap_Time___add__(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time___add__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time___add__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___add__" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Time___add__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -5861,11 +5487,13 @@ SWIGINTERN PyObject *_wrap_Time___add__(PyObject *SWIGUNUSEDPARM(self), PyObject resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_Time___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; Gempa::CAPS::TimeSpan *arg2 = 0 ; @@ -5873,17 +5501,15 @@ SWIGINTERN PyObject *_wrap_Time___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___sub__" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Time___sub__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -5895,11 +5521,13 @@ SWIGINTERN PyObject *_wrap_Time___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_Time___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; Gempa::CAPS::Time *arg2 = 0 ; @@ -5907,17 +5535,15 @@ SWIGINTERN PyObject *_wrap_Time___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::TimeSpan result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time___sub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___sub__" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Time___sub__" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -5929,7 +5555,9 @@ SWIGINTERN PyObject *_wrap_Time___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), resultobj = SWIG_NewPointerObj((new Gempa::CAPS::TimeSpan(static_cast< const Gempa::CAPS::TimeSpan& >(result))), SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -5938,23 +5566,19 @@ SWIGINTERN PyObject *_wrap_Time___sub__(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Time___sub__", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__Time, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time___sub____SWIG_1(self, args); + return _wrap_Time___sub____SWIG_1(self, argc, argv); } } } @@ -5964,10 +5588,10 @@ SWIGINTERN PyObject *_wrap_Time___sub__(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__Time, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Gempa__CAPS__TimeSpan, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time___sub____SWIG_0(self, args); + return _wrap_Time___sub____SWIG_0(self, argc, argv); } } } @@ -5986,17 +5610,16 @@ SWIGINTERN PyObject *_wrap_Time___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:Time___iadd__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time___iadd__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___iadd__" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Time___iadd__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -6020,17 +5643,16 @@ SWIGINTERN PyObject *_wrap_Time___isub__(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:Time___isub__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time___isub__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time___isub__" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Time___isub__" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -6072,53 +5694,46 @@ SWIGINTERN PyObject *_wrap_Time_set(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int ecode7 = 0 ; int val8 ; int ecode8 = 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 *swig_obj[8] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Time_set",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time_set", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_set" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_set" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "Time_set" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "Time_set" "', argument " "4"" of type '" "int""'"); } arg4 = static_cast< int >(val4); - ecode5 = SWIG_AsVal_int(obj4, &val5); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Time_set" "', argument " "5"" of type '" "int""'"); } arg5 = static_cast< int >(val5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Time_set" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Time_set" "', argument " "7"" of type '" "int""'"); } arg7 = static_cast< int >(val7); - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Time_set" "', argument " "8"" of type '" "int""'"); } @@ -6131,7 +5746,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6157,53 +5772,45 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyOb int res7 = 0 ; void *argp8 = 0 ; int res8 = 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 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Time_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Time_get" "', argument " "6"" of type '" "int *""'"); } arg6 = reinterpret_cast< int * >(argp6); - res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 | 0 ); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Time_get" "', argument " "7"" of type '" "int *""'"); } arg7 = reinterpret_cast< int * >(argp7); - res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 | 0 ); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Time_get" "', argument " "8"" of type '" "int *""'"); } @@ -6216,7 +5823,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6239,47 +5846,40 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyOb int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Time_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Time_get" "', argument " "6"" of type '" "int *""'"); } arg6 = reinterpret_cast< int * >(argp6); - res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 | 0 ); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Time_get" "', argument " "7"" of type '" "int *""'"); } @@ -6292,7 +5892,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6312,41 +5912,35 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyOb 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 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Time_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Time_get" "', argument " "6"" of type '" "int *""'"); } @@ -6359,7 +5953,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6376,35 +5970,30 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Time_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get" "', argument " "5"" of type '" "int *""'"); } @@ -6417,7 +6006,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6431,29 +6020,25 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:Time_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get" "', argument " "4"" of type '" "int *""'"); } @@ -6466,7 +6051,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6477,23 +6062,20 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Time_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get" "', argument " "3"" of type '" "int *""'"); } @@ -6506,7 +6088,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6514,17 +6096,15 @@ SWIGINTERN PyObject *_wrap_Time_get__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get" "', argument " "2"" of type '" "int *""'"); } @@ -6542,13 +6122,9 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { PyObject *argv[9] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 8) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Time_get", 0, 8, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; @@ -6559,7 +6135,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_6(self, args); + return _wrap_Time_get__SWIG_6(self, argc, argv); } } } @@ -6577,7 +6153,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_5(self, args); + return _wrap_Time_get__SWIG_5(self, argc, argv); } } } @@ -6600,7 +6176,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_4(self, args); + return _wrap_Time_get__SWIG_4(self, argc, argv); } } } @@ -6628,7 +6204,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_3(self, args); + return _wrap_Time_get__SWIG_3(self, argc, argv); } } } @@ -6661,7 +6237,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_2(self, args); + return _wrap_Time_get__SWIG_2(self, argc, argv); } } } @@ -6699,7 +6275,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_1(self, args); + return _wrap_Time_get__SWIG_1(self, argc, argv); } } } @@ -6742,7 +6318,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get__SWIG_0(self, args); + return _wrap_Time_get__SWIG_0(self, argc, argv); } } } @@ -6754,7 +6330,7 @@ SWIGINTERN PyObject *_wrap_Time_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Time_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Time_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Time::get(int *,int *,int *,int *,int *,int *,int *) const\n" " Gempa::CAPS::Time::get(int *,int *,int *,int *,int *,int *) const\n" @@ -6767,7 +6343,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6790,47 +6366,40 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyO int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Time_get2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get2" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get2" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get2" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Time_get2" "', argument " "6"" of type '" "int *""'"); } arg6 = reinterpret_cast< int * >(argp6); - res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 | 0 ); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Time_get2" "', argument " "7"" of type '" "int *""'"); } @@ -6843,7 +6412,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6863,41 +6432,35 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyO 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 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Time_get2",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get2" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get2" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get2" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Time_get2" "', argument " "6"" of type '" "int *""'"); } @@ -6910,7 +6473,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6927,35 +6490,30 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:Time_get2",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get2" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get2" "', argument " "4"" of type '" "int *""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Time_get2" "', argument " "5"" of type '" "int *""'"); } @@ -6968,7 +6526,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -6982,29 +6540,25 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyO int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:Time_get2",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get2" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Time_get2" "', argument " "4"" of type '" "int *""'"); } @@ -7017,7 +6571,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -7028,23 +6582,20 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Time_get2",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< 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 '" "Time_get2" "', argument " "3"" of type '" "int *""'"); } @@ -7057,7 +6608,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Time_get2__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Time_get2__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; int *arg2 = (int *) 0 ; @@ -7065,17 +6616,15 @@ SWIGINTERN PyObject *_wrap_Time_get2__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time_get2",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_get2" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_get2" "', argument " "2"" of type '" "int *""'"); } @@ -7093,13 +6642,9 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { PyObject *argv[8] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 7) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Time_get2", 0, 7, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; @@ -7110,7 +6655,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_5(self, args); + return _wrap_Time_get2__SWIG_5(self, argc, argv); } } } @@ -7128,7 +6673,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_4(self, args); + return _wrap_Time_get2__SWIG_4(self, argc, argv); } } } @@ -7151,7 +6696,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_3(self, args); + return _wrap_Time_get2__SWIG_3(self, argc, argv); } } } @@ -7179,7 +6724,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_2(self, args); + return _wrap_Time_get2__SWIG_2(self, argc, argv); } } } @@ -7212,7 +6757,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_1(self, args); + return _wrap_Time_get2__SWIG_1(self, argc, argv); } } } @@ -7250,7 +6795,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Time_get2__SWIG_0(self, args); + return _wrap_Time_get2__SWIG_0(self, argc, argv); } } } @@ -7261,7 +6806,7 @@ SWIGINTERN PyObject *_wrap_Time_get2(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Time_get2'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Time_get2'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Time::get2(int *,int *,int *,int *,int *,int *) const\n" " Gempa::CAPS::Time::get2(int *,int *,int *,int *,int *) const\n" @@ -7277,7 +6822,7 @@ SWIGINTERN PyObject *_wrap_Time_LocalTime(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *resultobj = 0; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)":Time_LocalTime")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Time_LocalTime", 0, 0, 0)) SWIG_fail; result = Gempa::CAPS::Time::LocalTime(); resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; @@ -7290,7 +6835,7 @@ SWIGINTERN PyObject *_wrap_Time_GMT(PyObject *SWIGUNUSEDPARM(self), PyObject *ar PyObject *resultobj = 0; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)":Time_GMT")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Time_GMT", 0, 0, 0)) SWIG_fail; result = Gempa::CAPS::Time::GMT(); resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; @@ -7307,17 +6852,16 @@ SWIGINTERN PyObject *_wrap_Time_FromYearDay(PyObject *SWIGUNUSEDPARM(self), PyOb int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time_FromYearDay",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_Python_UnpackTuple(args, "Time_FromYearDay", 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 '" "Time_FromYearDay" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "Time_FromYearDay" "', argument " "2"" of type '" "int""'"); } @@ -7335,11 +6879,12 @@ SWIGINTERN PyObject *_wrap_Time_localtime(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Time_localtime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_localtime" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } @@ -7357,11 +6902,12 @@ SWIGINTERN PyObject *_wrap_Time_gmt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Time_gmt",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_gmt" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } @@ -7379,11 +6925,12 @@ SWIGINTERN PyObject *_wrap_Time_toLocalTime(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:Time_toLocalTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_toLocalTime" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } @@ -7401,11 +6948,12 @@ SWIGINTERN PyObject *_wrap_Time_toGMT(PyObject *SWIGUNUSEDPARM(self), PyObject * Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:Time_toGMT",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_toGMT" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } @@ -7423,11 +6971,12 @@ SWIGINTERN PyObject *_wrap_Time_valid(PyObject *SWIGUNUSEDPARM(self), PyObject * Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Time_valid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_valid" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } @@ -7449,17 +6998,16 @@ SWIGINTERN PyObject *_wrap_Time_toString(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time_toString",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time_toString", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_toString" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_toString" "', argument " "2"" of type '" "char const *""'"); } @@ -7479,11 +7027,12 @@ SWIGINTERN PyObject *_wrap_Time_iso(PyObject *SWIGUNUSEDPARM(self), PyObject *ar Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"O:Time_iso",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_iso" "', argument " "1"" of type '" "Gempa::CAPS::Time const *""'"); } @@ -7509,23 +7058,21 @@ SWIGINTERN PyObject *_wrap_Time_fromString(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 ; char *buf3 = 0 ; int alloc3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Time_fromString",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Time_fromString", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Time_fromString" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Time * >(argp1); - 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 '" "Time_fromString" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "Time_fromString" "', argument " "3"" of type '" "char const *""'"); } @@ -7552,17 +7099,16 @@ SWIGINTERN PyObject *_wrap_Time_FromString(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"OO:Time_FromString",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_Python_UnpackTuple(args, "Time_FromString", 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 '" "Time_FromString" "', argument " "1"" of type '" "char const *""'"); } arg1 = reinterpret_cast< char * >(buf1); - 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 '" "Time_FromString" "', argument " "2"" of type '" "char const *""'"); } @@ -7584,10 +7130,11 @@ SWIGINTERN PyObject *_wrap_delete_Time(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Time *arg1 = (Gempa::CAPS::Time *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Time",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Time" "', argument " "1"" of type '" "Gempa::CAPS::Time *""'"); } @@ -7602,11 +7149,15 @@ fail: SWIGINTERN PyObject *Time_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Time, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Time_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_UOM_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::UOM *arg1 = (Gempa::CAPS::UOM *) 0 ; @@ -7615,16 +7166,15 @@ SWIGINTERN PyObject *_wrap_UOM_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; char temp2[4] ; int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:UOM_str_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "UOM_str_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UOM_str_set" "', argument " "1"" of type '" "Gempa::CAPS::UOM *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::UOM * >(argp1); - res2 = SWIG_AsCharArray(obj1, temp2, 4); + res2 = SWIG_AsCharArray(swig_obj[1], temp2, 4); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UOM_str_set" "', argument " "2"" of type '" "char [4]""'"); } @@ -7643,11 +7193,12 @@ SWIGINTERN PyObject *_wrap_UOM_str_get(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::UOM *arg1 = (Gempa::CAPS::UOM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:UOM_str_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UOM_str_get" "', argument " "1"" of type '" "Gempa::CAPS::UOM *""'"); } @@ -7674,16 +7225,15 @@ SWIGINTERN PyObject *_wrap_UOM_ID_set(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:UOM_ID_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "UOM_ID_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UOM_ID_set" "', argument " "1"" of type '" "Gempa::CAPS::UOM *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::UOM * >(argp1); - 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 '" "UOM_ID_set" "', argument " "2"" of type '" "int32_t""'"); } @@ -7701,11 +7251,12 @@ SWIGINTERN PyObject *_wrap_UOM_ID_get(PyObject *SWIGUNUSEDPARM(self), PyObject * Gempa::CAPS::UOM *arg1 = (Gempa::CAPS::UOM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:UOM_ID_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UOM_ID_get" "', argument " "1"" of type '" "Gempa::CAPS::UOM *""'"); } @@ -7722,7 +7273,7 @@ SWIGINTERN PyObject *_wrap_new_UOM(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *resultobj = 0; Gempa::CAPS::UOM *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_UOM")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_UOM", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::UOM *)new Gempa::CAPS::UOM(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__UOM, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -7736,10 +7287,11 @@ SWIGINTERN PyObject *_wrap_delete_UOM(PyObject *SWIGUNUSEDPARM(self), PyObject * Gempa::CAPS::UOM *arg1 = (Gempa::CAPS::UOM *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_UOM",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__UOM, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UOM" "', argument " "1"" of type '" "Gempa::CAPS::UOM *""'"); } @@ -7754,11 +7306,15 @@ fail: SWIGINTERN PyObject *UOM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__UOM, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *UOM_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_Quality_str_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Quality *arg1 = (Gempa::CAPS::Quality *) 0 ; @@ -7767,16 +7323,15 @@ SWIGINTERN PyObject *_wrap_Quality_str_set(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; char temp2[4] ; int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Quality_str_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Quality_str_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quality_str_set" "', argument " "1"" of type '" "Gempa::CAPS::Quality *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Quality * >(argp1); - res2 = SWIG_AsCharArray(obj1, temp2, 4); + res2 = SWIG_AsCharArray(swig_obj[1], temp2, 4); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quality_str_set" "', argument " "2"" of type '" "char [4]""'"); } @@ -7795,11 +7350,12 @@ SWIGINTERN PyObject *_wrap_Quality_str_get(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::Quality *arg1 = (Gempa::CAPS::Quality *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Quality_str_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quality_str_get" "', argument " "1"" of type '" "Gempa::CAPS::Quality *""'"); } @@ -7826,16 +7382,15 @@ SWIGINTERN PyObject *_wrap_Quality_ID_set(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Quality_ID_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Quality_ID_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quality_ID_set" "', argument " "1"" of type '" "Gempa::CAPS::Quality *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Quality * >(argp1); - 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 '" "Quality_ID_set" "', argument " "2"" of type '" "int32_t""'"); } @@ -7853,11 +7408,12 @@ SWIGINTERN PyObject *_wrap_Quality_ID_get(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::Quality *arg1 = (Gempa::CAPS::Quality *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Quality_ID_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quality_ID_get" "', argument " "1"" of type '" "Gempa::CAPS::Quality *""'"); } @@ -7874,7 +7430,7 @@ SWIGINTERN PyObject *_wrap_new_Quality(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *resultobj = 0; Gempa::CAPS::Quality *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Quality")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_Quality", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::Quality *)new Gempa::CAPS::Quality(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Quality, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -7888,10 +7444,11 @@ SWIGINTERN PyObject *_wrap_delete_Quality(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::Quality *arg1 = (Gempa::CAPS::Quality *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Quality",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Quality, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quality" "', argument " "1"" of type '" "Gempa::CAPS::Quality *""'"); } @@ -7906,11 +7463,15 @@ fail: SWIGINTERN PyObject *Quality_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Quality, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Quality_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_TimeStamp_year_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; @@ -7919,16 +7480,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_year_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_year_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_year_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_year_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_short(obj1, &val2); + ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_year_set" "', argument " "2"" of type '" "int16_t""'"); } @@ -7946,11 +7506,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_year_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_year_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_year_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -7971,16 +7532,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_yday_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_yday_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_yday_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_yday_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_yday_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -7998,11 +7558,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_yday_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_yday_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_yday_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8023,16 +7584,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_hour_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; unsigned char val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_hour_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_hour_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_hour_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_hour_set" "', argument " "2"" of type '" "uint8_t""'"); } @@ -8050,11 +7610,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_hour_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_hour_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_hour_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8075,16 +7636,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_minute_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; unsigned char val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_minute_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_minute_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_minute_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_minute_set" "', argument " "2"" of type '" "uint8_t""'"); } @@ -8102,11 +7662,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_minute_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_minute_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_minute_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8127,16 +7688,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_second_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; unsigned char val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_second_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_second_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_second_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_second_set" "', argument " "2"" of type '" "uint8_t""'"); } @@ -8154,11 +7714,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_second_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_second_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_second_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8179,16 +7740,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_unused_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; unsigned char val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_unused_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_unused_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_unused_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeStamp_unused_set" "', argument " "2"" of type '" "uint8_t""'"); } @@ -8206,11 +7766,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_unused_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_unused_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_unused_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8231,16 +7792,15 @@ SWIGINTERN PyObject *_wrap_TimeStamp_usec_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:TimeStamp_usec_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeStamp_usec_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_usec_set" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - 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 '" "TimeStamp_usec_set" "', argument " "2"" of type '" "int32_t""'"); } @@ -8258,11 +7818,12 @@ SWIGINTERN PyObject *_wrap_TimeStamp_usec_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:TimeStamp_usec_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeStamp_usec_get" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8279,7 +7840,7 @@ SWIGINTERN PyObject *_wrap_new_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *resultobj = 0; Gempa::CAPS::TimeStamp *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_TimeStamp")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_TimeStamp", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::TimeStamp *)new Gempa::CAPS::TimeStamp(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__TimeStamp, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -8293,10 +7854,11 @@ SWIGINTERN PyObject *_wrap_delete_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::TimeStamp *arg1 = (Gempa::CAPS::TimeStamp *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeStamp",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__TimeStamp, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeStamp" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp *""'"); } @@ -8311,16 +7873,20 @@ fail: SWIGINTERN PyObject *TimeStamp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__TimeStamp, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_PacketDataHeader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TimeStamp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_PacketDataHeader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::PacketDataHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_PacketDataHeader")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::PacketDataHeader *)new Gempa::CAPS::PacketDataHeader(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -8329,16 +7895,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_PacketDataHeader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_PacketDataHeader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; uint16_t arg1 ; unsigned short val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::PacketDataHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_PacketDataHeader",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_short(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PacketDataHeader" "', argument " "1"" of type '" "uint16_t""'"); } @@ -8356,15 +7921,11 @@ SWIGINTERN PyObject *_wrap_new_PacketDataHeader(PyObject *self, PyObject *args) PyObject *argv[2] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_PacketDataHeader", 0, 1, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_PacketDataHeader__SWIG_0(self, args); + return _wrap_new_PacketDataHeader__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -8373,12 +7934,12 @@ SWIGINTERN PyObject *_wrap_new_PacketDataHeader(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_PacketDataHeader__SWIG_1(self, args); + return _wrap_new_PacketDataHeader__SWIG_1(self, argc, argv); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PacketDataHeader'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PacketDataHeader'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::PacketDataHeader::PacketDataHeader()\n" " Gempa::CAPS::PacketDataHeader::PacketDataHeader(uint16_t)\n"); @@ -8394,16 +7955,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_version_set(PyObject *SWIGUNUSEDPARM int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_version_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_version_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_version_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketDataHeader_version_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -8421,11 +7981,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_version_get(PyObject *SWIGUNUSEDPARM Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeader_version_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_version_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -8446,16 +8007,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_packetType_set(PyObject *SWIGUNUSEDP int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_packetType_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_packetType_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_packetType_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - 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 '" "PacketDataHeader_packetType_set" "', argument " "2"" of type '" "Gempa::CAPS::PacketType""'"); } @@ -8473,11 +8033,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_packetType_get(PyObject *SWIGUNUSEDP Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeader_packetType_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_packetType_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -8498,16 +8059,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_unitOfMeasurement_set(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_unitOfMeasurement_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_unitOfMeasurement_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_unitOfMeasurement_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__UOM, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeader_unitOfMeasurement_set" "', argument " "2"" of type '" "Gempa::CAPS::UOM *""'"); } @@ -8525,11 +8085,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_unitOfMeasurement_get(PyObject *SWIG Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::UOM *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeader_unitOfMeasurement_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_unitOfMeasurement_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -8551,17 +8112,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_setUOM(PyObject *SWIGUNUSEDPARM(self int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_setUOM",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_setUOM", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_setUOM" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - 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 '" "PacketDataHeader_setUOM" "', argument " "2"" of type '" "char const *""'"); } @@ -8576,7 +8136,7 @@ fail: } -SWIGINTERN PyObject *_wrap_PacketDataHeader_uom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PacketDataHeader_uom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; char arg2 ; @@ -8584,17 +8144,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_uom__SWIG_0(PyObject *SWIGUNUSEDPARM int res1 = 0 ; char val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_uom",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_uom" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - ecode2 = SWIG_AsVal_char(obj1, &val2); + ecode2 = SWIG_AsVal_char(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketDataHeader_uom" "', argument " "2"" of type '" "char""'"); } @@ -8607,16 +8165,15 @@ fail: } -SWIGINTERN PyObject *_wrap_PacketDataHeader_uom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PacketDataHeader_uom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeader_uom",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_uom" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader const *""'"); } @@ -8634,20 +8191,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_uom(PyObject *self, PyObject *args) PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "PacketDataHeader_uom", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_PacketDataHeader_uom__SWIG_1(self, args); + return _wrap_PacketDataHeader_uom__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -8661,13 +8214,13 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_uom(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_PacketDataHeader_uom__SWIG_0(self, args); + return _wrap_PacketDataHeader_uom__SWIG_0(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PacketDataHeader_uom'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PacketDataHeader_uom'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::PacketDataHeader::uom(char) const\n" " Gempa::CAPS::PacketDataHeader::uom() const\n"); @@ -8683,17 +8236,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader___ne__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader___ne__" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeader___ne__" "', argument " "2"" of type '" "Gempa::CAPS::PacketDataHeader const &""'"); } @@ -8705,7 +8257,9 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader___ne__(PyObject *SWIGUNUSEDPARM(self resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -8714,11 +8268,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_dataSize(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeader_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader const *""'"); } @@ -8739,17 +8294,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_put(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_put" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeader_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -8773,17 +8327,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeader_get(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeader_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeader_get", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeader_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -8804,10 +8357,11 @@ SWIGINTERN PyObject *_wrap_delete_PacketDataHeader(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::PacketDataHeader *arg1 = (Gempa::CAPS::PacketDataHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_PacketDataHeader",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PacketDataHeader" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -8822,16 +8376,20 @@ fail: SWIGINTERN PyObject *PacketDataHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *PacketDataHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_PacketDataHeaderV2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::PacketDataHeaderV2 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_PacketDataHeaderV2")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_PacketDataHeaderV2", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::PacketDataHeaderV2 *)new Gempa::CAPS::PacketDataHeaderV2(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -8848,16 +8406,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_samplingFrequencyNumerator_set(PyO int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2_samplingFrequencyNumerator_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2_samplingFrequencyNumerator_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_samplingFrequencyNumerator_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketDataHeaderV2_samplingFrequencyNumerator_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -8875,11 +8432,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_samplingFrequencyNumerator_get(PyO Gempa::CAPS::PacketDataHeaderV2 *arg1 = (Gempa::CAPS::PacketDataHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeaderV2_samplingFrequencyNumerator_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_samplingFrequencyNumerator_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } @@ -8900,16 +8458,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_samplingFrequencyDenominator_set(P int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2_samplingFrequencyDenominator_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2_samplingFrequencyDenominator_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_samplingFrequencyDenominator_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketDataHeaderV2_samplingFrequencyDenominator_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -8927,11 +8484,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_samplingFrequencyDenominator_get(P Gempa::CAPS::PacketDataHeaderV2 *arg1 = (Gempa::CAPS::PacketDataHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeaderV2_samplingFrequencyDenominator_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_samplingFrequencyDenominator_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } @@ -8952,16 +8510,15 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_quality_set(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2_quality_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2_quality_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_quality_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__Quality, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeaderV2_quality_set" "', argument " "2"" of type '" "Gempa::CAPS::Quality *""'"); } @@ -8979,11 +8536,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_quality_get(PyObject *SWIGUNUSEDPA Gempa::CAPS::PacketDataHeaderV2 *arg1 = (Gempa::CAPS::PacketDataHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Quality *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeaderV2_quality_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_quality_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } @@ -9004,17 +8562,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2___ne__(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2___ne__" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeaderV2___ne__" "', argument " "2"" of type '" "Gempa::CAPS::PacketDataHeaderV2 const &""'"); } @@ -9026,7 +8583,9 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2___ne__(PyObject *SWIGUNUSEDPARM(se resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -9035,11 +8594,12 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_dataSize(PyObject *SWIGUNUSEDPARM( Gempa::CAPS::PacketDataHeaderV2 *arg1 = (Gempa::CAPS::PacketDataHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketDataHeaderV2_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 const *""'"); } @@ -9060,17 +8620,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_put(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_put" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeaderV2_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9094,17 +8653,16 @@ SWIGINTERN PyObject *_wrap_PacketDataHeaderV2_get(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketDataHeaderV2_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketDataHeaderV2_get", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketDataHeaderV2_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketDataHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketDataHeaderV2_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9125,10 +8683,11 @@ SWIGINTERN PyObject *_wrap_delete_PacketDataHeaderV2(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::PacketDataHeaderV2 *arg1 = (Gempa::CAPS::PacketDataHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_PacketDataHeaderV2",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PacketDataHeaderV2" "', argument " "1"" of type '" "Gempa::CAPS::PacketDataHeaderV2 *""'"); } @@ -9143,11 +8702,15 @@ fail: SWIGINTERN PyObject *PacketDataHeaderV2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__PacketDataHeaderV2, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *PacketDataHeaderV2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_PacketHeaderV1_SIDSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::PacketHeaderV1 *arg1 = (Gempa::CAPS::PacketHeaderV1 *) 0 ; @@ -9156,16 +8719,15 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_SIDSize_set(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV1_SIDSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV1_SIDSize_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_SIDSize_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV1 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 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 '" "PacketHeaderV1_SIDSize_set" "', argument " "2"" of type '" "uint8_t [4]""'"); } @@ -9190,11 +8752,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_SIDSize_get(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::PacketHeaderV1 *arg1 = (Gempa::CAPS::PacketHeaderV1 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV1_SIDSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_SIDSize_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } @@ -9215,16 +8778,15 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_size_set(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV1_size_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV1_size_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_size_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV1 * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketHeaderV1_size_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -9242,11 +8804,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_size_get(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::PacketHeaderV1 *arg1 = (Gempa::CAPS::PacketHeaderV1 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV1_size_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_size_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } @@ -9267,17 +8830,16 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_put(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV1_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV1_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_put" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV1 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketHeaderV1_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9298,11 +8860,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV1_dataSize(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::PacketHeaderV1 *arg1 = (Gempa::CAPS::PacketHeaderV1 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV1_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV1_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 const *""'"); } @@ -9319,7 +8882,7 @@ SWIGINTERN PyObject *_wrap_new_PacketHeaderV1(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; Gempa::CAPS::PacketHeaderV1 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_PacketHeaderV1")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_PacketHeaderV1", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::PacketHeaderV1 *)new Gempa::CAPS::PacketHeaderV1(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -9333,10 +8896,11 @@ SWIGINTERN PyObject *_wrap_delete_PacketHeaderV1(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::PacketHeaderV1 *arg1 = (Gempa::CAPS::PacketHeaderV1 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_PacketHeaderV1",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PacketHeaderV1" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV1 *""'"); } @@ -9351,11 +8915,15 @@ fail: SWIGINTERN PyObject *PacketHeaderV1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__PacketHeaderV1, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *PacketHeaderV1_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_PacketHeaderV2_SIDSize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::PacketHeaderV2 *arg1 = (Gempa::CAPS::PacketHeaderV2 *) 0 ; @@ -9364,16 +8932,15 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_SIDSize_set(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV2_SIDSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV2_SIDSize_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_SIDSize_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 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 '" "PacketHeaderV2_SIDSize_set" "', argument " "2"" of type '" "uint8_t [4]""'"); } @@ -9398,11 +8965,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_SIDSize_get(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::PacketHeaderV2 *arg1 = (Gempa::CAPS::PacketHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV2_SIDSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_SIDSize_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } @@ -9423,16 +8991,15 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_size_set(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV2_size_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV2_size_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_size_set" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV2 * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PacketHeaderV2_size_set" "', argument " "2"" of type '" "uint32_t""'"); } @@ -9450,11 +9017,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_size_get(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::PacketHeaderV2 *arg1 = (Gempa::CAPS::PacketHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV2_size_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_size_get" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } @@ -9475,17 +9043,16 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_put(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:PacketHeaderV2_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "PacketHeaderV2_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_put" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::PacketHeaderV2 * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PacketHeaderV2_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9506,11 +9073,12 @@ SWIGINTERN PyObject *_wrap_PacketHeaderV2_dataSize(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::PacketHeaderV2 *arg1 = (Gempa::CAPS::PacketHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:PacketHeaderV2_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PacketHeaderV2_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 const *""'"); } @@ -9527,7 +9095,7 @@ SWIGINTERN PyObject *_wrap_new_PacketHeaderV2(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; Gempa::CAPS::PacketHeaderV2 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_PacketHeaderV2")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_PacketHeaderV2", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::PacketHeaderV2 *)new Gempa::CAPS::PacketHeaderV2(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -9541,10 +9109,11 @@ SWIGINTERN PyObject *_wrap_delete_PacketHeaderV2(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::PacketHeaderV2 *arg1 = (Gempa::CAPS::PacketHeaderV2 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_PacketHeaderV2",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PacketHeaderV2" "', argument " "1"" of type '" "Gempa::CAPS::PacketHeaderV2 *""'"); } @@ -9559,11 +9128,15 @@ fail: SWIGINTERN PyObject *PacketHeaderV2_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__PacketHeaderV2, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *PacketHeaderV2_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_ResponseHeader_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::ResponseHeader *arg1 = (Gempa::CAPS::ResponseHeader *) 0 ; @@ -9572,16 +9145,15 @@ SWIGINTERN PyObject *_wrap_ResponseHeader_id_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:ResponseHeader_id_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ResponseHeader_id_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResponseHeader_id_set" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::ResponseHeader * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResponseHeader_id_set" "', argument " "2"" of type '" "uint16_t""'"); } @@ -9599,11 +9171,12 @@ SWIGINTERN PyObject *_wrap_ResponseHeader_id_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::ResponseHeader *arg1 = (Gempa::CAPS::ResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint16_t result; - if (!PyArg_ParseTuple(args,(char *)"O:ResponseHeader_id_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResponseHeader_id_get" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } @@ -9624,16 +9197,15 @@ SWIGINTERN PyObject *_wrap_ResponseHeader_size_set(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:ResponseHeader_size_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ResponseHeader_size_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResponseHeader_size_set" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::ResponseHeader * >(argp1); - 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 '" "ResponseHeader_size_set" "', argument " "2"" of type '" "int32_t""'"); } @@ -9651,11 +9223,12 @@ SWIGINTERN PyObject *_wrap_ResponseHeader_size_get(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::ResponseHeader *arg1 = (Gempa::CAPS::ResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:ResponseHeader_size_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResponseHeader_size_get" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } @@ -9676,17 +9249,16 @@ SWIGINTERN PyObject *_wrap_ResponseHeader_get(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ResponseHeader_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ResponseHeader_get", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResponseHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::ResponseHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResponseHeader_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9706,7 +9278,7 @@ SWIGINTERN PyObject *_wrap_new_ResponseHeader(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; Gempa::CAPS::ResponseHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_ResponseHeader")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_ResponseHeader", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::ResponseHeader *)new Gempa::CAPS::ResponseHeader(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__ResponseHeader, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -9720,10 +9292,11 @@ SWIGINTERN PyObject *_wrap_delete_ResponseHeader(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::ResponseHeader *arg1 = (Gempa::CAPS::ResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_ResponseHeader",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__ResponseHeader, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResponseHeader" "', argument " "1"" of type '" "Gempa::CAPS::ResponseHeader *""'"); } @@ -9738,20 +9311,25 @@ fail: SWIGINTERN PyObject *ResponseHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__ResponseHeader, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *ResponseHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_delete_DataRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_DataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataRecord" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -9769,11 +9347,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_formatName(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -9806,21 +9385,16 @@ SWIGINTERN PyObject *_wrap_DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(self 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[6] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DataRecord_readMetaData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DataRecord_readMetaData", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_readMetaData" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -9828,12 +9402,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "DataRecord_readMetaData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } @@ -9841,7 +9415,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } @@ -9849,7 +9423,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DataRecord_readMetaData" "', argument " "6"" of type '" "Gempa::CAPS::Time &""'"); } @@ -9870,11 +9444,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_canTrim(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -9892,11 +9467,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_canMerge(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -9920,18 +9496,16 @@ SWIGINTERN PyObject *_wrap_DataRecord_trim(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:DataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -9939,7 +9513,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_trim(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -9955,7 +9529,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_dataSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_dataSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; bool arg2 ; @@ -9963,17 +9537,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_dataSize__SWIG_0(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"OO:DataRecord_dataSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataRecord_dataSize" "', argument " "2"" of type '" "bool""'"); } @@ -9986,16 +9558,15 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_dataSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_dataSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -10013,20 +9584,16 @@ SWIGINTERN PyObject *_wrap_DataRecord_dataSize(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "DataRecord_dataSize", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__DataRecord, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DataRecord_dataSize__SWIG_1(self, args); + return _wrap_DataRecord_dataSize__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -10040,13 +9607,13 @@ SWIGINTERN PyObject *_wrap_DataRecord_dataSize(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DataRecord_dataSize__SWIG_0(self, args); + return _wrap_DataRecord_dataSize__SWIG_0(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DataRecord_dataSize'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DataRecord_dataSize'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::DataRecord::dataSize(bool) const\n" " Gempa::CAPS::DataRecord::dataSize() const\n"); @@ -10054,7 +9621,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10074,21 +9641,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self) int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10096,12 +9657,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "DataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -10109,7 +9670,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -10117,7 +9678,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -10130,7 +9691,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10147,20 +9708,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self) int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:DataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10168,12 +9724,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "DataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -10181,7 +9737,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -10197,7 +9753,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10211,19 +9767,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self) int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:DataRecord_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10231,12 +9783,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "DataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -10252,7 +9804,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10263,18 +9815,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOO:DataRecord_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10282,7 +9831,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "DataRecord_get" "', argument " "3"" of type '" "int""'"); } @@ -10300,13 +9849,9 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "DataRecord_get", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -10314,7 +9859,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10322,7 +9867,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DataRecord_get__SWIG_3(self, args); + return _wrap_DataRecord_get__SWIG_3(self, argc, argv); } } } @@ -10334,7 +9879,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10342,10 +9887,10 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DataRecord_get__SWIG_2(self, args); + return _wrap_DataRecord_get__SWIG_2(self, argc, argv); } } } @@ -10358,7 +9903,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10366,13 +9911,13 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DataRecord_get__SWIG_1(self, args); + return _wrap_DataRecord_get__SWIG_1(self, argc, argv); } } } @@ -10386,7 +9931,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10394,10 +9939,10 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -10405,7 +9950,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DataRecord_get__SWIG_0(self, args); + return _wrap_DataRecord_get__SWIG_0(self, argc, argv); } } } @@ -10415,7 +9960,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DataRecord_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DataRecord_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::DataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::DataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n" @@ -10425,7 +9970,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10436,18 +9981,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; bool val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:DataRecord_put",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10455,7 +9997,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataRecord_put" "', argument " "3"" of type '" "bool""'"); } @@ -10468,7 +10010,7 @@ fail: } -SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -10476,17 +10018,15 @@ SWIGINTERN PyObject *_wrap_DataRecord_put__SWIG_1(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:DataRecord_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -10507,13 +10047,9 @@ SWIGINTERN PyObject *_wrap_DataRecord_put(PyObject *self, PyObject *args) { PyObject *argv[4] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "DataRecord_put", 0, 3, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; @@ -10521,10 +10057,10 @@ SWIGINTERN PyObject *_wrap_DataRecord_put(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DataRecord_put__SWIG_1(self, args); + return _wrap_DataRecord_put__SWIG_1(self, argc, argv); } } } @@ -10535,7 +10071,7 @@ SWIGINTERN PyObject *_wrap_DataRecord_put(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10543,14 +10079,14 @@ SWIGINTERN PyObject *_wrap_DataRecord_put(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DataRecord_put__SWIG_0(self, args); + return _wrap_DataRecord_put__SWIG_0(self, argc, argv); } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DataRecord_put'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DataRecord_put'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::DataRecord::put(std::streambuf &,bool) const\n" " Gempa::CAPS::DataRecord::put(std::streambuf &) const\n"); @@ -10563,11 +10099,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_header(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_header" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -10585,11 +10122,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_startTime(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_startTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_startTime" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -10607,11 +10145,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_endTime(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_endTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_endTime" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -10629,11 +10168,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_packetType(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord const *""'"); } @@ -10651,11 +10191,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_buffer(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Buffer *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_buffer",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_buffer" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -10673,11 +10214,12 @@ SWIGINTERN PyObject *_wrap_DataRecord_data(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::DataRecord *arg1 = (Gempa::CAPS::DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Buffer *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:DataRecord_data",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataRecord_data" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -10692,7 +10234,7 @@ fail: SWIGINTERN PyObject *DataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -10705,16 +10247,15 @@ SWIGINTERN PyObject *_wrap_RawPacket_header_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawPacket_header_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawPacket_header_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_header_set" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawPacket_header_set" "', argument " "2"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -10732,11 +10273,12 @@ SWIGINTERN PyObject *_wrap_RawPacket_header_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawPacket *arg1 = (Gempa::CAPS::RawPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketDataHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RawPacket_header_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_header_get" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } @@ -10757,16 +10299,15 @@ SWIGINTERN PyObject *_wrap_RawPacket_SID_set(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawPacket_SID_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawPacket_SID_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_SID_set" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__string, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawPacket_SID_set" "', argument " "2"" of type '" "std::string [4]""'"); } @@ -10791,11 +10332,12 @@ SWIGINTERN PyObject *_wrap_RawPacket_SID_get(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::RawPacket *arg1 = (Gempa::CAPS::RawPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RawPacket_SID_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_SID_get" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } @@ -10816,17 +10358,16 @@ SWIGINTERN PyObject *_wrap_RawPacket_data_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawPacket_data_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawPacket_data_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_data_set" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawPacket * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_char_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_char_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawPacket_data_set" "', argument " "2"" of type '" "std::vector< char >""'"); } @@ -10851,11 +10392,12 @@ SWIGINTERN PyObject *_wrap_RawPacket_data_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::RawPacket *arg1 = (Gempa::CAPS::RawPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::vector< char > result; - if (!PyArg_ParseTuple(args,(char *)"O:RawPacket_data_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_data_get" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } @@ -10876,16 +10418,15 @@ SWIGINTERN PyObject *_wrap_RawPacket_record_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawPacket_record_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawPacket_record_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_record_set" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawPacket_record_set" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -10903,11 +10444,12 @@ SWIGINTERN PyObject *_wrap_RawPacket_record_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawPacket *arg1 = (Gempa::CAPS::RawPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RawPacket_record_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawPacket_record_get" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } @@ -10924,7 +10466,7 @@ SWIGINTERN PyObject *_wrap_new_RawPacket(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *resultobj = 0; Gempa::CAPS::RawPacket *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_RawPacket")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_RawPacket", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RawPacket *)new Gempa::CAPS::RawPacket(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RawPacket, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -10938,10 +10480,11 @@ SWIGINTERN PyObject *_wrap_delete_RawPacket(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::RawPacket *arg1 = (Gempa::CAPS::RawPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_RawPacket",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawPacket, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawPacket" "', argument " "1"" of type '" "Gempa::CAPS::RawPacket *""'"); } @@ -10956,11 +10499,15 @@ fail: SWIGINTERN PyObject *RawPacket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RawPacket, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *RawPacket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_MetaPacket_SID_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; @@ -10969,16 +10516,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_SID_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_SID_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_SID_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_SID_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__string, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_SID_set" "', argument " "2"" of type '" "std::string [4]""'"); } @@ -11003,11 +10549,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_SID_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_SID_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_SID_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11028,16 +10575,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_packetDataHeader_set(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_packetDataHeader_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_packetDataHeader_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_packetDataHeader_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_packetDataHeader_set" "', argument " "2"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -11055,11 +10601,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_packetDataHeader_get(PyObject *SWIGUNUSEDP Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketDataHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_packetDataHeader_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_packetDataHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11080,16 +10627,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_record_set(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_record_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_record_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_record_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_record_set" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -11107,11 +10653,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_record_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_record_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_record_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11132,16 +10679,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_recordHeader_set(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_recordHeader_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_recordHeader_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_recordHeader_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_recordHeader_set" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord::Header *""'"); } @@ -11159,11 +10705,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_recordHeader_get(PyObject *SWIGUNUSEDPARM( Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_recordHeader_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_recordHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11184,16 +10731,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_startTime_set(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_startTime_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_startTime_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_startTime_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_startTime_set" "', argument " "2"" of type '" "Gempa::CAPS::Time *""'"); } @@ -11211,11 +10757,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_startTime_get(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_startTime_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_startTime_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11236,16 +10783,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_endTime_set(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_endTime_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_endTime_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_endTime_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_endTime_set" "', argument " "2"" of type '" "Gempa::CAPS::Time *""'"); } @@ -11263,11 +10809,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_endTime_get(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_endTime_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_endTime_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11288,16 +10835,15 @@ SWIGINTERN PyObject *_wrap_MetaPacket_timestamp_set(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:MetaPacket_timestamp_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MetaPacket_timestamp_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_timestamp_set" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MetaPacket * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetaPacket_timestamp_set" "', argument " "2"" of type '" "Gempa::CAPS::Time *""'"); } @@ -11315,11 +10861,12 @@ SWIGINTERN PyObject *_wrap_MetaPacket_timestamp_get(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MetaPacket_timestamp_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetaPacket_timestamp_get" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11336,7 +10883,7 @@ SWIGINTERN PyObject *_wrap_new_MetaPacket(PyObject *SWIGUNUSEDPARM(self), PyObje PyObject *resultobj = 0; Gempa::CAPS::MetaPacket *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_MetaPacket")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_MetaPacket", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::MetaPacket *)new Gempa::CAPS::MetaPacket(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__MetaPacket, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -11350,10 +10897,11 @@ SWIGINTERN PyObject *_wrap_delete_MetaPacket(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::MetaPacket *arg1 = (Gempa::CAPS::MetaPacket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MetaPacket",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MetaPacket, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MetaPacket" "', argument " "1"" of type '" "Gempa::CAPS::MetaPacket *""'"); } @@ -11368,16 +10916,20 @@ fail: SWIGINTERN PyObject *MetaPacket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__MetaPacket, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_Packet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MetaPacket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_Packet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::Packet *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Packet")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::Packet *)new Gempa::CAPS::Packet(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Packet, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -11386,7 +10938,7 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::DataRecordPtr arg1 ; std::string *arg2 = 0 ; @@ -11399,16 +10951,11 @@ SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py int res3 = SWIG_OLDOBJ ; int res4 = SWIG_OLDOBJ ; int res5 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::Packet *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Packet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Packet" "', argument " "1"" of type '" "Gempa::CAPS::DataRecordPtr""'"); } @@ -11422,7 +10969,7 @@ SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Packet" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11433,7 +10980,7 @@ SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Packet" "', argument " "3"" of type '" "std::string const &""'"); } @@ -11444,7 +10991,7 @@ SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Packet" "', argument " "4"" of type '" "std::string const &""'"); } @@ -11455,7 +11002,7 @@ SWIGINTERN PyObject *_wrap_new_Packet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Packet" "', argument " "5"" of type '" "std::string const &""'"); } @@ -11485,19 +11032,15 @@ SWIGINTERN PyObject *_wrap_new_Packet(PyObject *self, PyObject *args) { PyObject *argv[6] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 5) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Packet", 0, 5, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_Packet__SWIG_0(self, args); + return _wrap_new_Packet__SWIG_0(self, argc, argv); } if (argc == 5) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); @@ -11512,7 +11055,7 @@ SWIGINTERN PyObject *_wrap_new_Packet(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Packet__SWIG_1(self, args); + return _wrap_new_Packet__SWIG_1(self, argc, argv); } } } @@ -11521,7 +11064,7 @@ SWIGINTERN PyObject *_wrap_new_Packet(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Packet'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Packet'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Packet::Packet()\n" " Gempa::CAPS::Packet::Packet(Gempa::CAPS::DataRecordPtr,std::string const &,std::string const &,std::string const &,std::string const &)\n"); @@ -11534,11 +11077,12 @@ SWIGINTERN PyObject *_wrap_Packet_clone(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Packet *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_clone",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_clone" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11559,17 +11103,16 @@ SWIGINTERN PyObject *_wrap_Packet_buffer_set(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_buffer_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_buffer_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_buffer_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__Packet__Buffer_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__Packet__Buffer_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_buffer_set" "', argument " "2"" of type '" "Gempa::CAPS::Packet::BufferPtr""'"); } @@ -11594,11 +11137,12 @@ SWIGINTERN PyObject *_wrap_Packet_buffer_get(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Packet::BufferPtr result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_buffer_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_buffer_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11619,17 +11163,16 @@ SWIGINTERN PyObject *_wrap_Packet_record_set(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_record_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_record_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_record_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_record_set" "', argument " "2"" of type '" "Gempa::CAPS::DataRecordPtr""'"); } @@ -11654,11 +11197,12 @@ SWIGINTERN PyObject *_wrap_Packet_record_get(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecordPtr result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_record_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_record_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11678,18 +11222,17 @@ SWIGINTERN PyObject *_wrap_Packet_networkCode_set(PyObject *SWIGUNUSEDPARM(self) void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_networkCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_networkCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_networkCode_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_networkCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11713,11 +11256,12 @@ SWIGINTERN PyObject *_wrap_Packet_networkCode_get(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_networkCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_networkCode_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11737,18 +11281,17 @@ SWIGINTERN PyObject *_wrap_Packet_stationCode_set(PyObject *SWIGUNUSEDPARM(self) void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_stationCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_stationCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_stationCode_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_stationCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11772,11 +11315,12 @@ SWIGINTERN PyObject *_wrap_Packet_stationCode_get(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_stationCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_stationCode_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11796,18 +11340,17 @@ SWIGINTERN PyObject *_wrap_Packet_locationCode_set(PyObject *SWIGUNUSEDPARM(self void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_locationCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_locationCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_locationCode_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_locationCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11831,11 +11374,12 @@ SWIGINTERN PyObject *_wrap_Packet_locationCode_get(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_locationCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_locationCode_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11855,18 +11399,17 @@ SWIGINTERN PyObject *_wrap_Packet_channelCode_set(PyObject *SWIGUNUSEDPARM(self) void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_channelCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_channelCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_channelCode_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_channelCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11890,11 +11433,12 @@ SWIGINTERN PyObject *_wrap_Packet_channelCode_get(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_channelCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_channelCode_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11914,18 +11458,17 @@ SWIGINTERN PyObject *_wrap_Packet_streamID_set(PyObject *SWIGUNUSEDPARM(self), P void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_streamID_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_streamID_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_streamID_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_streamID_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -11949,11 +11492,12 @@ SWIGINTERN PyObject *_wrap_Packet_streamID_get(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_streamID_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_streamID_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -11974,16 +11518,15 @@ SWIGINTERN PyObject *_wrap_Packet_dataType_set(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_dataType_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_dataType_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_dataType_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); - 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 '" "Packet_dataType_set" "', argument " "2"" of type '" "Gempa::CAPS::DataType""'"); } @@ -12001,11 +11544,12 @@ SWIGINTERN PyObject *_wrap_Packet_dataType_get(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataType result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_dataType_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_dataType_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -12026,16 +11570,15 @@ SWIGINTERN PyObject *_wrap_Packet_dt_us_set(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; long long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_dt_us_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_dt_us_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_dt_us_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Packet_dt_us_set" "', argument " "2"" of type '" "int64_t""'"); } @@ -12053,11 +11596,12 @@ SWIGINTERN PyObject *_wrap_Packet_dt_us_get(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int64_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_dt_us_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_dt_us_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -12077,18 +11621,17 @@ SWIGINTERN PyObject *_wrap_Packet_uom_set(PyObject *SWIGUNUSEDPARM(self), PyObje void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_uom_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_uom_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_uom_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Packet_uom_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -12112,11 +11655,12 @@ SWIGINTERN PyObject *_wrap_Packet_uom_get(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_uom_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_uom_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -12137,16 +11681,15 @@ SWIGINTERN PyObject *_wrap_Packet_timingQuality_set(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Packet_timingQuality_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Packet_timingQuality_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_timingQuality_set" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Packet * >(argp1); - 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 '" "Packet_timingQuality_set" "', argument " "2"" of type '" "int""'"); } @@ -12164,11 +11707,12 @@ SWIGINTERN PyObject *_wrap_Packet_timingQuality_get(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_timingQuality_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_timingQuality_get" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -12186,11 +11730,12 @@ SWIGINTERN PyObject *_wrap_Packet_size(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Packet_size",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Packet_size" "', argument " "1"" of type '" "Gempa::CAPS::Packet const *""'"); } @@ -12208,10 +11753,11 @@ SWIGINTERN PyObject *_wrap_delete_Packet(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::Packet *arg1 = (Gempa::CAPS::Packet *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Packet",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Packet, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Packet" "', argument " "1"" of type '" "Gempa::CAPS::Packet *""'"); } @@ -12226,16 +11772,20 @@ fail: SWIGINTERN PyObject *Packet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Packet, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Packet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_AnyDataRecord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::AnyDataRecord *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_AnyDataRecord")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AnyDataRecord", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::AnyDataRecord *)new Gempa::CAPS::AnyDataRecord(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -12253,17 +11803,16 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_setType(PyObject *SWIGUNUSEDPARM(self), int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:AnyDataRecord_setType",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_setType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_setType" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - 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 '" "AnyDataRecord_setType" "', argument " "2"" of type '" "char const *""'"); } @@ -12283,11 +11832,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_type(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_type",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_type" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12305,11 +11855,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_formatName(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12342,21 +11893,16 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s 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[6] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:AnyDataRecord_readMetaData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_readMetaData", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_readMetaData" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12364,12 +11910,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "AnyDataRecord_readMetaData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AnyDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } @@ -12377,7 +11923,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "AnyDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } @@ -12385,7 +11931,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "AnyDataRecord_readMetaData" "', argument " "6"" of type '" "Gempa::CAPS::Time &""'"); } @@ -12406,11 +11952,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_header(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_header" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12428,11 +11975,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_startTime(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_startTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_startTime" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12450,11 +11998,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_endTime(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_endTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_endTime" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12472,11 +12021,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_canTrim(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12494,11 +12044,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_canMerge(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -12522,18 +12073,16 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:AnyDataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12541,7 +12090,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AnyDataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12565,17 +12114,16 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_dataSize(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"OO:AnyDataRecord_dataSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_dataSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnyDataRecord_dataSize" "', argument " "2"" of type '" "bool""'"); } @@ -12588,7 +12136,7 @@ fail: } -SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -12608,21 +12156,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:AnyDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12630,12 +12172,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "AnyDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AnyDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12643,7 +12185,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "AnyDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12651,7 +12193,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "AnyDataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -12664,7 +12206,7 @@ fail: } -SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -12681,20 +12223,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:AnyDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12702,12 +12239,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "AnyDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AnyDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12715,7 +12252,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "AnyDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12731,7 +12268,7 @@ fail: } -SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -12745,19 +12282,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(se int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:AnyDataRecord_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12765,12 +12298,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "AnyDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AnyDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -12786,7 +12319,7 @@ fail: } -SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -12797,18 +12330,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOO:AnyDataRecord_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12816,7 +12346,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "AnyDataRecord_get" "', argument " "3"" of type '" "int""'"); } @@ -12834,13 +12364,9 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "AnyDataRecord_get", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -12848,7 +12374,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -12856,7 +12382,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_AnyDataRecord_get__SWIG_3(self, args); + return _wrap_AnyDataRecord_get__SWIG_3(self, argc, argv); } } } @@ -12868,7 +12394,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -12876,10 +12402,10 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_AnyDataRecord_get__SWIG_2(self, args); + return _wrap_AnyDataRecord_get__SWIG_2(self, argc, argv); } } } @@ -12892,7 +12418,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -12900,13 +12426,13 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_AnyDataRecord_get__SWIG_1(self, args); + return _wrap_AnyDataRecord_get__SWIG_1(self, argc, argv); } } } @@ -12920,7 +12446,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -12928,10 +12454,10 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -12939,7 +12465,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_AnyDataRecord_get__SWIG_0(self, args); + return _wrap_AnyDataRecord_get__SWIG_0(self, argc, argv); } } } @@ -12949,7 +12475,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'AnyDataRecord_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AnyDataRecord_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::AnyDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::AnyDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n" @@ -12970,18 +12496,16 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_put(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; bool val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:AnyDataRecord_put",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_put", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -12989,7 +12513,7 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_put(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AnyDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnyDataRecord_put" "', argument " "3"" of type '" "bool""'"); } @@ -13007,11 +12531,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_packetType(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord const *""'"); } @@ -13032,16 +12557,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_setStartTime(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:AnyDataRecord_setStartTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_setStartTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_setStartTime" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -13065,16 +12589,15 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_setEndTime(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:AnyDataRecord_setEndTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_setEndTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_setEndTime" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AnyDataRecord_setEndTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -13101,22 +12624,20 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_setSamplingFrequency(PyObject *SWIGUNUS int ecode2 = 0 ; unsigned short val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; - if (!PyArg_ParseTuple(args,(char *)"OOO:AnyDataRecord_setSamplingFrequency",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_setSamplingFrequency", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_setSamplingFrequency" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AnyDataRecord_setSamplingFrequency" "', argument " "2"" of type '" "uint16_t""'"); } arg2 = static_cast< uint16_t >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnyDataRecord_setSamplingFrequency" "', argument " "3"" of type '" "uint16_t""'"); } @@ -13134,11 +12655,12 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_data(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::AnyDataRecord::Buffer *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:AnyDataRecord_data",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_data" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } @@ -13163,22 +12685,20 @@ SWIGINTERN PyObject *_wrap_AnyDataRecord_setData(PyObject *SWIGUNUSEDPARM(self), int alloc2 = 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:AnyDataRecord_setData",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AnyDataRecord_setData", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AnyDataRecord_setData" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::AnyDataRecord * >(argp1); - 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 '" "AnyDataRecord_setData" "', argument " "2"" of type '" "char *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_size_t(obj2, &val3); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AnyDataRecord_setData" "', argument " "3"" of type '" "size_t""'"); } @@ -13198,10 +12718,11 @@ SWIGINTERN PyObject *_wrap_delete_AnyDataRecord(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::AnyDataRecord *arg1 = (Gempa::CAPS::AnyDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_AnyDataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AnyDataRecord" "', argument " "1"" of type '" "Gempa::CAPS::AnyDataRecord *""'"); } @@ -13216,11 +12737,15 @@ fail: SWIGINTERN PyObject *AnyDataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__AnyDataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *AnyDataRecord_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN int Swig_var_LogHandler_set(PyObject *_val) { { Gempa::CAPS::LogOutput *inp = 0; @@ -13254,17 +12779,16 @@ SWIGINTERN PyObject *_wrap_SetLogHandler(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::LogOutput arg2 = (Gempa::CAPS::LogOutput) 0 ; int val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SetLogHandler",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_Python_UnpackTuple(args, "SetLogHandler", 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 '" "SetLogHandler" "', argument " "1"" of type '" "Gempa::CAPS::LogLevel""'"); } arg1 = static_cast< Gempa::CAPS::LogLevel >(val1); { - int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_v_______void); + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char_v_______void); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SetLogHandler" "', argument " "2"" of type '" "Gempa::CAPS::LogOutput""'"); } @@ -13277,50 +12801,6 @@ fail: } -SWIGINTERN PyObject *_wrap_SPClock_freqn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:SPClock_freqn_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_freqn_get" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); - } - arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); - result = (int)(int) ((arg1)->freqn); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SPClock_freqd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - int result; - - if (!PyArg_ParseTuple(args,(char *)"O:SPClock_freqd_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_freqd_get" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); - } - arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); - result = (int)(int) ((arg1)->freqd); - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_new_SPClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; int arg1 ; @@ -13329,17 +12809,16 @@ SWIGINTERN PyObject *_wrap_new_SPClock(PyObject *SWIGUNUSEDPARM(self), PyObject int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::SPClock *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:new_SPClock",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_Python_UnpackTuple(args, "new_SPClock", 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 '" "new_SPClock" "', argument " "1"" of type '" "int""'"); } arg1 = static_cast< 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 '" "new_SPClock" "', argument " "2"" of type '" "int""'"); } @@ -13352,32 +12831,31 @@ fail: } -SWIGINTERN PyObject *_wrap_SPClock_sync_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SPClock_syncTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; - Gempa::CAPS::SPClock::INT_TIME *arg2 = 0 ; + Gempa::CAPS::Time *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SPClock_sync_time",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SPClock_syncTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_sync_time" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_syncTime" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SPClock_sync_time" "', argument " "2"" of type '" "Gempa::CAPS::SPClock::INT_TIME const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SPClock_syncTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SPClock_sync_time" "', argument " "2"" of type '" "Gempa::CAPS::SPClock::INT_TIME const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SPClock_syncTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } - arg2 = reinterpret_cast< Gempa::CAPS::SPClock::INT_TIME * >(argp2); - (arg1)->sync_time((Gempa::CAPS::SPClock::INT_TIME const &)*arg2); + arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); + (arg1)->syncTime((Gempa::CAPS::Time const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -13390,10 +12868,11 @@ SWIGINTERN PyObject *_wrap_SPClock_tick(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:SPClock_tick",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_tick" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); } @@ -13406,7 +12885,7 @@ fail: } -SWIGINTERN PyObject *_wrap_SPClock_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SPClock_getTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; int arg2 ; @@ -13414,23 +12893,22 @@ SWIGINTERN PyObject *_wrap_SPClock_get_time(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - Gempa::CAPS::SPClock::INT_TIME result; + PyObject *swig_obj[2] ; + Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"OO:SPClock_get_time",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SPClock_getTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_get_time" "', argument " "1"" of type '" "Gempa::CAPS::SPClock const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_getTime" "', argument " "1"" of type '" "Gempa::CAPS::SPClock const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); - 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 '" "SPClock_get_time" "', argument " "2"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SPClock_getTime" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - result = ((Gempa::CAPS::SPClock const *)arg1)->get_time(arg2); - resultobj = SWIG_NewPointerObj((new Gempa::CAPS::SPClock::INT_TIME(static_cast< const Gempa::CAPS::SPClock::INT_TIME& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); + result = ((Gempa::CAPS::SPClock const *)arg1)->getTime(arg2); + resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; @@ -13442,11 +12920,12 @@ SWIGINTERN PyObject *_wrap_SPClock_correction(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:SPClock_correction",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_correction" "', argument " "1"" of type '" "Gempa::CAPS::SPClock const *""'"); } @@ -13459,15 +12938,62 @@ fail: } +SWIGINTERN PyObject *_wrap_SPClock_freqn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 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_Gempa__CAPS__SPClock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_freqn_get" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); + result = (int)(int) ((arg1)->freqn); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SPClock_freqd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 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_Gempa__CAPS__SPClock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SPClock_freqd_get" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::SPClock * >(argp1); + result = (int)(int) ((arg1)->freqd); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_SPClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::SPClock *arg1 = (Gempa::CAPS::SPClock *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SPClock",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SPClock, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SPClock" "', argument " "1"" of type '" "Gempa::CAPS::SPClock *""'"); } @@ -13482,20 +13008,25 @@ fail: SWIGINTERN PyObject *SPClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__SPClock, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *SPClock_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_delete_Encoder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Encoder",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Encoder" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13515,16 +13046,15 @@ SWIGINTERN PyObject *_wrap_Encoder_push(PyObject *SWIGUNUSEDPARM(self), PyObject void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Encoder_push",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Encoder_push", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_push" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Encoder * >(argp1); - res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Encoder_push" "', argument " "2"" of type '" "void *""'"); } @@ -13541,10 +13071,11 @@ SWIGINTERN PyObject *_wrap_Encoder_flush(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_flush",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_flush" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13562,10 +13093,11 @@ SWIGINTERN PyObject *_wrap_Encoder_reset(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_reset",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_reset" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13583,11 +13115,12 @@ SWIGINTERN PyObject *_wrap_Encoder_type(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_type",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_type" "', argument " "1"" of type '" "Gempa::CAPS::Encoder const *""'"); } @@ -13605,11 +13138,12 @@ SWIGINTERN PyObject *_wrap_Encoder_clk(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::SPClock *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_clk",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_clk" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13625,29 +13159,28 @@ fail: SWIGINTERN PyObject *_wrap_Encoder_setStartTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; - Gempa::CAPS::SPClock::INT_TIME *arg2 = 0 ; + Gempa::CAPS::Time *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Encoder_setStartTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Encoder_setStartTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_setStartTime" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Encoder * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Encoder_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::SPClock::INT_TIME const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Encoder_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Encoder_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::SPClock::INT_TIME const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Encoder_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } - arg2 = reinterpret_cast< Gempa::CAPS::SPClock::INT_TIME * >(argp2); - (arg1)->setStartTime((Gempa::CAPS::SPClock::INT_TIME const &)*arg2); + arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); + (arg1)->setStartTime((Gempa::CAPS::Time const &)*arg2); resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -13660,17 +13193,18 @@ SWIGINTERN PyObject *_wrap_Encoder_currentTime(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; - Gempa::CAPS::SPClock::INT_TIME result; + PyObject *swig_obj[1] ; + Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_currentTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_currentTime" "', argument " "1"" of type '" "Gempa::CAPS::Encoder const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Encoder * >(argp1); result = ((Gempa::CAPS::Encoder const *)arg1)->currentTime(); - resultobj = SWIG_NewPointerObj((new Gempa::CAPS::SPClock::INT_TIME(static_cast< const Gempa::CAPS::SPClock::INT_TIME& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); + resultobj = SWIG_NewPointerObj((new Gempa::CAPS::Time(static_cast< const Gempa::CAPS::Time& >(result))), SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; @@ -13682,11 +13216,12 @@ SWIGINTERN PyObject *_wrap_Encoder_timingQuality(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_timingQuality",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_timingQuality" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13707,16 +13242,15 @@ SWIGINTERN PyObject *_wrap_Encoder_setTimingQuality(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Encoder_setTimingQuality",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Encoder_setTimingQuality", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_setTimingQuality" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Encoder * >(argp1); - 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 '" "Encoder_setTimingQuality" "', argument " "2"" of type '" "int""'"); } @@ -13734,11 +13268,12 @@ SWIGINTERN PyObject *_wrap_Encoder_pop(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Encoder *arg1 = (Gempa::CAPS::Encoder *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketPtr result; - if (!PyArg_ParseTuple(args,(char *)"O:Encoder_pop",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Encoder, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Encoder_pop" "', argument " "1"" of type '" "Gempa::CAPS::Encoder *""'"); } @@ -13753,7 +13288,7 @@ fail: SWIGINTERN PyObject *Encoder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Encoder, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -13763,10 +13298,11 @@ SWIGINTERN PyObject *_wrap_delete_EncoderFactory(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::EncoderFactory *arg1 = (Gempa::CAPS::EncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_EncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::EncoderFactory *""'"); } @@ -13801,25 +13337,18 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), int ecode7 = 0 ; int val8 ; int ecode8 = 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 *swig_obj[8] ; Gempa::CAPS::Encoder *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:EncoderFactory_create",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "EncoderFactory_create", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderFactory_create" "', argument " "1"" of type '" "Gempa::CAPS::EncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::EncoderFactory * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EncoderFactory_create" "', argument " "2"" of type '" "std::string const &""'"); } @@ -13830,7 +13359,7 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EncoderFactory_create" "', argument " "3"" of type '" "std::string const &""'"); } @@ -13841,7 +13370,7 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "EncoderFactory_create" "', argument " "4"" of type '" "std::string const &""'"); } @@ -13852,7 +13381,7 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "EncoderFactory_create" "', argument " "5"" of type '" "std::string const &""'"); } @@ -13861,17 +13390,17 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), } arg5 = ptr; } - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "EncoderFactory_create" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "EncoderFactory_create" "', argument " "7"" of type '" "int""'"); } arg7 = static_cast< int >(val7); - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "EncoderFactory_create" "', argument " "8"" of type '" "int""'"); } @@ -13900,17 +13429,16 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_supportsRecord(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:EncoderFactory_supportsRecord",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "EncoderFactory_supportsRecord", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderFactory_supportsRecord" "', argument " "1"" of type '" "Gempa::CAPS::EncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::EncoderFactory * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EncoderFactory_supportsRecord" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -13928,11 +13456,12 @@ SWIGINTERN PyObject *_wrap_EncoderFactory_errorString(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::EncoderFactory *arg1 = (Gempa::CAPS::EncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:EncoderFactory_errorString",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EncoderFactory_errorString" "', argument " "1"" of type '" "Gempa::CAPS::EncoderFactory const *""'"); } @@ -13947,7 +13476,7 @@ fail: SWIGINTERN PyObject *EncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__EncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -13955,34 +13484,25 @@ SWIGINTERN PyObject *EncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_MSEEDEncoderFactory_setRecordLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDEncoderFactory *arg1 = (Gempa::CAPS::MSEEDEncoderFactory *) 0 ; - uint arg2 ; + unsigned int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:MSEEDEncoderFactory_setRecordLength",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDEncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDEncoderFactory_setRecordLength", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDEncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDEncoderFactory_setRecordLength" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDEncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDEncoderFactory * >(argp1); - { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_uint, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDEncoderFactory_setRecordLength" "', argument " "2"" of type '" "uint""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDEncoderFactory_setRecordLength" "', argument " "2"" of type '" "uint""'"); - } else { - uint * temp = reinterpret_cast< uint * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } + ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSEEDEncoderFactory_setRecordLength" "', argument " "2"" of type '" "unsigned int""'"); + } + arg2 = static_cast< unsigned int >(val2); result = (bool)(arg1)->setRecordLength(arg2); resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; @@ -13996,10 +13516,11 @@ SWIGINTERN PyObject *_wrap_delete_MSEEDEncoderFactory(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::MSEEDEncoderFactory *arg1 = (Gempa::CAPS::MSEEDEncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MSEEDEncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDEncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDEncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MSEEDEncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDEncoderFactory *""'"); } @@ -14014,7 +13535,7 @@ fail: SWIGINTERN PyObject *MSEEDEncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__MSEEDEncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -14027,17 +13548,16 @@ SWIGINTERN PyObject *_wrap_SteimEncoderFactory_supportsRecord(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SteimEncoderFactory_supportsRecord",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SteimEncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SteimEncoderFactory_supportsRecord", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SteimEncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SteimEncoderFactory_supportsRecord" "', argument " "1"" of type '" "Gempa::CAPS::SteimEncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SteimEncoderFactory * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SteimEncoderFactory_supportsRecord" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -14055,10 +13575,11 @@ SWIGINTERN PyObject *_wrap_delete_SteimEncoderFactory(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::SteimEncoderFactory *arg1 = (Gempa::CAPS::SteimEncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SteimEncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SteimEncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SteimEncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SteimEncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::SteimEncoderFactory *""'"); } @@ -14073,7 +13594,7 @@ fail: SWIGINTERN PyObject *SteimEncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__SteimEncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -14100,25 +13621,18 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_create(PyObject *SWIGUNUSEDPAR int ecode7 = 0 ; int val8 ; int ecode8 = 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 *swig_obj[8] ; Gempa::CAPS::Encoder *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:IdentityEncoderFactory_create",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "IdentityEncoderFactory_create", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityEncoderFactory_create" "', argument " "1"" of type '" "Gempa::CAPS::IdentityEncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::IdentityEncoderFactory * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityEncoderFactory_create" "', argument " "2"" of type '" "std::string const &""'"); } @@ -14129,7 +13643,7 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_create(PyObject *SWIGUNUSEDPAR } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityEncoderFactory_create" "', argument " "3"" of type '" "std::string const &""'"); } @@ -14140,7 +13654,7 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_create(PyObject *SWIGUNUSEDPAR } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityEncoderFactory_create" "', argument " "4"" of type '" "std::string const &""'"); } @@ -14151,7 +13665,7 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_create(PyObject *SWIGUNUSEDPAR } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityEncoderFactory_create" "', argument " "5"" of type '" "std::string const &""'"); } @@ -14160,17 +13674,17 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_create(PyObject *SWIGUNUSEDPAR } arg5 = ptr; } - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IdentityEncoderFactory_create" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IdentityEncoderFactory_create" "', argument " "7"" of type '" "int""'"); } arg7 = static_cast< int >(val7); - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "IdentityEncoderFactory_create" "', argument " "8"" of type '" "int""'"); } @@ -14199,17 +13713,16 @@ SWIGINTERN PyObject *_wrap_IdentityEncoderFactory_supportsRecord(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:IdentityEncoderFactory_supportsRecord",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "IdentityEncoderFactory_supportsRecord", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityEncoderFactory_supportsRecord" "', argument " "1"" of type '" "Gempa::CAPS::IdentityEncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::IdentityEncoderFactory * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__DataRecord, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityEncoderFactory_supportsRecord" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord *""'"); } @@ -14226,7 +13739,7 @@ SWIGINTERN PyObject *_wrap_new_IdentityEncoderFactory(PyObject *SWIGUNUSEDPARM(s PyObject *resultobj = 0; Gempa::CAPS::IdentityEncoderFactory *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_IdentityEncoderFactory")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_IdentityEncoderFactory", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::IdentityEncoderFactory *)new Gempa::CAPS::IdentityEncoderFactory(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -14240,10 +13753,11 @@ SWIGINTERN PyObject *_wrap_delete_IdentityEncoderFactory(PyObject *SWIGUNUSEDPAR Gempa::CAPS::IdentityEncoderFactory *arg1 = (Gempa::CAPS::IdentityEncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_IdentityEncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityEncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::IdentityEncoderFactory *""'"); } @@ -14258,11 +13772,15 @@ fail: SWIGINTERN PyObject *IdentityEncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__IdentityEncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *IdentityEncoderFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Steim1EncoderFactory *arg1 = (Gempa::CAPS::Steim1EncoderFactory *) 0 ; @@ -14285,25 +13803,18 @@ SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM( int ecode7 = 0 ; int val8 ; int ecode8 = 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 *swig_obj[8] ; Gempa::CAPS::Encoder *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Steim1EncoderFactory_create",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Steim1EncoderFactory_create", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Steim1EncoderFactory_create" "', argument " "1"" of type '" "Gempa::CAPS::Steim1EncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Steim1EncoderFactory * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Steim1EncoderFactory_create" "', argument " "2"" of type '" "std::string const &""'"); } @@ -14314,7 +13825,7 @@ SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Steim1EncoderFactory_create" "', argument " "3"" of type '" "std::string const &""'"); } @@ -14325,7 +13836,7 @@ SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Steim1EncoderFactory_create" "', argument " "4"" of type '" "std::string const &""'"); } @@ -14336,7 +13847,7 @@ SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Steim1EncoderFactory_create" "', argument " "5"" of type '" "std::string const &""'"); } @@ -14345,17 +13856,17 @@ SWIGINTERN PyObject *_wrap_Steim1EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } arg5 = ptr; } - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Steim1EncoderFactory_create" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Steim1EncoderFactory_create" "', argument " "7"" of type '" "int""'"); } arg7 = static_cast< int >(val7); - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Steim1EncoderFactory_create" "', argument " "8"" of type '" "int""'"); } @@ -14380,7 +13891,7 @@ SWIGINTERN PyObject *_wrap_new_Steim1EncoderFactory(PyObject *SWIGUNUSEDPARM(sel PyObject *resultobj = 0; Gempa::CAPS::Steim1EncoderFactory *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Steim1EncoderFactory")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_Steim1EncoderFactory", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::Steim1EncoderFactory *)new Gempa::CAPS::Steim1EncoderFactory(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -14394,10 +13905,11 @@ SWIGINTERN PyObject *_wrap_delete_Steim1EncoderFactory(PyObject *SWIGUNUSEDPARM( Gempa::CAPS::Steim1EncoderFactory *arg1 = (Gempa::CAPS::Steim1EncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Steim1EncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Steim1EncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::Steim1EncoderFactory *""'"); } @@ -14412,11 +13924,15 @@ fail: SWIGINTERN PyObject *Steim1EncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Steim1EncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Steim1EncoderFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Steim2EncoderFactory *arg1 = (Gempa::CAPS::Steim2EncoderFactory *) 0 ; @@ -14439,25 +13955,18 @@ SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM( int ecode7 = 0 ; int val8 ; int ecode8 = 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 *swig_obj[8] ; Gempa::CAPS::Encoder *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Steim2EncoderFactory_create",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Steim2EncoderFactory_create", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Steim2EncoderFactory_create" "', argument " "1"" of type '" "Gempa::CAPS::Steim2EncoderFactory *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Steim2EncoderFactory * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Steim2EncoderFactory_create" "', argument " "2"" of type '" "std::string const &""'"); } @@ -14468,7 +13977,7 @@ SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Steim2EncoderFactory_create" "', argument " "3"" of type '" "std::string const &""'"); } @@ -14479,7 +13988,7 @@ SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Steim2EncoderFactory_create" "', argument " "4"" of type '" "std::string const &""'"); } @@ -14490,7 +13999,7 @@ SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Steim2EncoderFactory_create" "', argument " "5"" of type '" "std::string const &""'"); } @@ -14499,17 +14008,17 @@ SWIGINTERN PyObject *_wrap_Steim2EncoderFactory_create(PyObject *SWIGUNUSEDPARM( } arg5 = ptr; } - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Steim2EncoderFactory_create" "', argument " "6"" of type '" "int""'"); } arg6 = static_cast< int >(val6); - ecode7 = SWIG_AsVal_int(obj6, &val7); + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Steim2EncoderFactory_create" "', argument " "7"" of type '" "int""'"); } arg7 = static_cast< int >(val7); - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Steim2EncoderFactory_create" "', argument " "8"" of type '" "int""'"); } @@ -14534,7 +14043,7 @@ SWIGINTERN PyObject *_wrap_new_Steim2EncoderFactory(PyObject *SWIGUNUSEDPARM(sel PyObject *resultobj = 0; Gempa::CAPS::Steim2EncoderFactory *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Steim2EncoderFactory")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_Steim2EncoderFactory", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::Steim2EncoderFactory *)new Gempa::CAPS::Steim2EncoderFactory(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -14548,10 +14057,11 @@ SWIGINTERN PyObject *_wrap_delete_Steim2EncoderFactory(PyObject *SWIGUNUSEDPARM( Gempa::CAPS::Steim2EncoderFactory *arg1 = (Gempa::CAPS::Steim2EncoderFactory *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Steim2EncoderFactory",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Steim2EncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::Steim2EncoderFactory *""'"); } @@ -14566,21 +14076,26 @@ fail: SWIGINTERN PyObject *Steim2EncoderFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Steim2EncoderFactory, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Steim2EncoderFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_MSEEDDataRecord_formatName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14613,21 +14128,16 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM 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[6] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MSEEDDataRecord_readMetaData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_readMetaData", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_readMetaData" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -14635,12 +14145,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "MSEEDDataRecord_readMetaData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSEEDDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } @@ -14648,7 +14158,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MSEEDDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } @@ -14656,7 +14166,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MSEEDDataRecord_readMetaData" "', argument " "6"" of type '" "Gempa::CAPS::Time &""'"); } @@ -14677,11 +14187,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_header(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_header" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14699,11 +14210,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_startTime(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_startTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_startTime" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14721,11 +14233,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_endTime(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_endTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_endTime" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14743,11 +14256,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_canTrim(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14765,11 +14279,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_canMerge(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -14793,18 +14308,16 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:MSEEDDataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -14812,7 +14325,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MSEEDDataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -14836,17 +14349,16 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_dataSize(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"OO:MSEEDDataRecord_dataSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_dataSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MSEEDDataRecord_dataSize" "', argument " "2"" of type '" "bool""'"); } @@ -14859,7 +14371,7 @@ fail: } -SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -14879,21 +14391,15 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MSEEDDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -14901,12 +14407,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "MSEEDDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSEEDDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -14914,7 +14420,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MSEEDDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -14922,7 +14428,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MSEEDDataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -14935,7 +14441,7 @@ fail: } -SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -14952,20 +14458,15 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:MSEEDDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -14973,12 +14474,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "MSEEDDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSEEDDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -14986,7 +14487,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MSEEDDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -15002,7 +14503,7 @@ fail: } -SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -15016,19 +14517,15 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM( int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:MSEEDDataRecord_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -15036,12 +14533,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "MSEEDDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MSEEDDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -15057,7 +14554,7 @@ fail: } -SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -15068,18 +14565,15 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOO:MSEEDDataRecord_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -15087,7 +14581,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "MSEEDDataRecord_get" "', argument " "3"" of type '" "int""'"); } @@ -15105,13 +14599,9 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_get", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -15119,7 +14609,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -15127,7 +14617,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_MSEEDDataRecord_get__SWIG_3(self, args); + return _wrap_MSEEDDataRecord_get__SWIG_3(self, argc, argv); } } } @@ -15139,7 +14629,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -15147,10 +14637,10 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MSEEDDataRecord_get__SWIG_2(self, args); + return _wrap_MSEEDDataRecord_get__SWIG_2(self, argc, argv); } } } @@ -15163,7 +14653,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -15171,13 +14661,13 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MSEEDDataRecord_get__SWIG_1(self, args); + return _wrap_MSEEDDataRecord_get__SWIG_1(self, argc, argv); } } } @@ -15191,7 +14681,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -15199,10 +14689,10 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -15210,7 +14700,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_MSEEDDataRecord_get__SWIG_0(self, args); + return _wrap_MSEEDDataRecord_get__SWIG_0(self, argc, argv); } } } @@ -15220,7 +14710,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MSEEDDataRecord_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MSEEDDataRecord_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::MSEEDDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::MSEEDDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n" @@ -15241,18 +14731,16 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_put(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; bool val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:MSEEDDataRecord_put",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_put", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -15260,7 +14748,7 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_put(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MSEEDDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSEEDDataRecord_put" "', argument " "3"" of type '" "bool""'"); } @@ -15278,11 +14766,12 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_packetType(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord const *""'"); } @@ -15305,21 +14794,19 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_setData(PyObject *SWIGUNUSEDPARM(self int res2 ; 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:MSEEDDataRecord_setData",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MSEEDDataRecord_setData", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_setData" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::MSEEDDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MSEEDDataRecord_setData" "', argument " "2"" of type '" "void const *""'"); } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MSEEDDataRecord_setData" "', argument " "3"" of type '" "size_t""'"); } @@ -15337,10 +14824,11 @@ SWIGINTERN PyObject *_wrap_MSEEDDataRecord_unpackHeader(PyObject *SWIGUNUSEDPARM Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:MSEEDDataRecord_unpackHeader",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MSEEDDataRecord_unpackHeader" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } @@ -15358,10 +14846,11 @@ SWIGINTERN PyObject *_wrap_delete_MSEEDDataRecord(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::MSEEDDataRecord *arg1 = (Gempa::CAPS::MSEEDDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_MSEEDDataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MSEEDDataRecord" "', argument " "1"" of type '" "Gempa::CAPS::MSEEDDataRecord *""'"); } @@ -15376,12 +14865,12 @@ fail: SWIGINTERN PyObject *MSEEDDataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__MSEEDDataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; @@ -15389,15 +14878,12 @@ SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::Plugin *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:new_Plugin",&obj0,&obj1,&obj2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Plugin" "', argument " "1"" of type '" "std::string const &""'"); } @@ -15408,7 +14894,7 @@ SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Plugin" "', argument " "2"" of type '" "std::string const &""'"); } @@ -15419,7 +14905,7 @@ SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Plugin" "', argument " "3"" of type '" "std::string const &""'"); } @@ -15442,20 +14928,18 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; int res1 = SWIG_OLDOBJ ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::Plugin *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:new_Plugin",&obj0,&obj1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Plugin" "', argument " "1"" of type '" "std::string const &""'"); } @@ -15466,7 +14950,7 @@ SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Plugin" "', argument " "2"" of type '" "std::string const &""'"); } @@ -15487,17 +14971,16 @@ fail: } -SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Plugin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; Gempa::CAPS::Plugin *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_Plugin",&obj0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Plugin" "', argument " "1"" of type '" "std::string const &""'"); } @@ -15521,19 +15004,15 @@ SWIGINTERN PyObject *_wrap_new_Plugin(PyObject *self, PyObject *args) { PyObject *argv[4] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Plugin", 0, 3, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Plugin__SWIG_2(self, args); + return _wrap_new_Plugin__SWIG_2(self, argc, argv); } } if (argc == 2) { @@ -15544,7 +15023,7 @@ SWIGINTERN PyObject *_wrap_new_Plugin(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Plugin__SWIG_1(self, args); + return _wrap_new_Plugin__SWIG_1(self, argc, argv); } } } @@ -15559,14 +15038,14 @@ SWIGINTERN PyObject *_wrap_new_Plugin(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Plugin__SWIG_0(self, args); + return _wrap_new_Plugin__SWIG_0(self, argc, argv); } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Plugin'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Plugin'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Plugin::Plugin(std::string const &,std::string const &,std::string const &)\n" " Gempa::CAPS::Plugin::Plugin(std::string const &,std::string const &)\n" @@ -15580,10 +15059,11 @@ SWIGINTERN PyObject *_wrap_delete_Plugin(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Plugin",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Plugin" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -15601,10 +15081,11 @@ SWIGINTERN PyObject *_wrap_Plugin_close(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_close",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_close" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -15622,10 +15103,11 @@ SWIGINTERN PyObject *_wrap_Plugin_quit(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_quit",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_quit" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -15643,10 +15125,11 @@ SWIGINTERN PyObject *_wrap_Plugin_enableLogging(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_enableLogging",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_enableLogging" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -15667,16 +15150,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setBackfillingBufferSize(PyObject *SWIGUNUSEDP int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setBackfillingBufferSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setBackfillingBufferSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setBackfillingBufferSize" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - 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 '" "Plugin_setBackfillingBufferSize" "', argument " "2"" of type '" "int""'"); } @@ -15694,11 +15176,12 @@ SWIGINTERN PyObject *_wrap_Plugin_backfillingBufferSize(PyObject *SWIGUNUSEDPARM Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_backfillingBufferSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_backfillingBufferSize" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } @@ -15716,11 +15199,12 @@ SWIGINTERN PyObject *_wrap_Plugin_isExitRequested(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_isExitRequested",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_isExitRequested" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -15738,71 +15222,202 @@ SWIGINTERN PyObject *_wrap_Plugin_stats(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Plugin::Stats *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_stats",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_stats" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } - arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - result = (Gempa::CAPS::Plugin::Stats *) &((Gempa::CAPS::Plugin const *)arg1)->stats(); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Plugin__Stats, 0 | 0 ); + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + result = (Gempa::CAPS::Plugin::Stats *) &((Gempa::CAPS::Plugin const *)arg1)->stats(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Plugin__Stats, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_resetMaxBytesBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 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_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_resetMaxBytesBuffered" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + (arg1)->resetMaxBytesBuffered(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_setEncoderFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + Gempa::CAPS::EncoderFactory *arg2 = (Gempa::CAPS::EncoderFactory *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Plugin_setEncoderFactory", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setEncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setEncoderFactory" "', argument " "2"" of type '" "Gempa::CAPS::EncoderFactory *""'"); + } + arg2 = reinterpret_cast< Gempa::CAPS::EncoderFactory * >(argp2); + (arg1)->setEncoderFactory(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_setAddress__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + std::string *arg2 = 0 ; + uint16_t arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + unsigned short val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setAddress" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setAddress" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_setAddress" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Plugin_setAddress" "', argument " "3"" of type '" "uint16_t""'"); + } + arg3 = static_cast< uint16_t >(val3); + result = (bool)(arg1)->setAddress((std::string const &)*arg2,arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: + if (SWIG_IsNewObj(res2)) delete arg2; return NULL; } -SWIGINTERN PyObject *_wrap_Plugin_resetMaxBytesBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_setAddress__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + int res2 = SWIG_OLDOBJ ; + bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_resetMaxBytesBuffered",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_resetMaxBytesBuffered" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setAddress" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - (arg1)->resetMaxBytesBuffered(); - resultobj = SWIG_Py_Void(); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setAddress" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_setAddress" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + result = (bool)(arg1)->setAddress((std::string const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (SWIG_IsNewObj(res2)) delete arg2; return resultobj; fail: + if (SWIG_IsNewObj(res2)) delete arg2; return NULL; } -SWIGINTERN PyObject *_wrap_Plugin_setEncoderFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; - Gempa::CAPS::EncoderFactory *arg2 = (Gempa::CAPS::EncoderFactory *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; +SWIGINTERN PyObject *_wrap_Plugin_setAddress(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setEncoderFactory",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setEncoderFactory" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "Plugin_setAddress", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__Plugin, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Plugin_setAddress__SWIG_1(self, argc, argv); + } + } } - arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__EncoderFactory, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setEncoderFactory" "', argument " "2"" of type '" "Gempa::CAPS::EncoderFactory *""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__Plugin, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Plugin_setAddress__SWIG_0(self, argc, argv); + } + } + } } - arg2 = reinterpret_cast< Gempa::CAPS::EncoderFactory * >(argp2); - (arg1)->setEncoderFactory(arg2); - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Plugin_setAddress'.\n" + " Possible C/C++ prototypes are:\n" + " Gempa::CAPS::Plugin::setAddress(std::string const &,uint16_t)\n" + " Gempa::CAPS::Plugin::setAddress(std::string const &)\n"); + return 0; } @@ -15813,18 +15428,17 @@ SWIGINTERN PyObject *_wrap_Plugin_setHost(PyObject *SWIGUNUSEDPARM(self), PyObje void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setHost",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setHost", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setHost" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setHost" "', argument " "2"" of type '" "std::string const &""'"); } @@ -15848,11 +15462,12 @@ SWIGINTERN PyObject *_wrap_Plugin_host(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_host",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_host" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } @@ -15873,16 +15488,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setPort(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; unsigned short val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setPort",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setPort", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setPort" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Plugin_setPort" "', argument " "2"" of type '" "unsigned short""'"); } @@ -15900,11 +15514,12 @@ SWIGINTERN PyObject *_wrap_Plugin_port(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; unsigned short result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_port",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_port" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } @@ -15925,16 +15540,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setBufferSize(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setBufferSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setBufferSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setBufferSize" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Plugin_setBufferSize" "', argument " "2"" of type '" "size_t""'"); } @@ -15952,11 +15566,12 @@ SWIGINTERN PyObject *_wrap_Plugin_bufferSize(PyObject *SWIGUNUSEDPARM(self), PyO Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_bufferSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_bufferSize" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } @@ -15977,16 +15592,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setSSLEnabled(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setSSLEnabled",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setSSLEnabled", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setSSLEnabled" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Plugin_setSSLEnabled" "', argument " "2"" of type '" "bool""'"); } @@ -16008,19 +15622,17 @@ SWIGINTERN PyObject *_wrap_Plugin_setCredentials(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int res2 = SWIG_OLDOBJ ; int res3 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; - if (!PyArg_ParseTuple(args,(char *)"OOO:Plugin_setCredentials",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setCredentials", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setCredentials" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setCredentials" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16031,7 +15643,7 @@ SWIGINTERN PyObject *_wrap_Plugin_setCredentials(PyObject *SWIGUNUSEDPARM(self), } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_setCredentials" "', argument " "3"" of type '" "std::string const &""'"); } @@ -16060,16 +15672,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setMaxFutureEndTime(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setMaxFutureEndTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setMaxFutureEndTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setMaxFutureEndTime" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setMaxFutureEndTime" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -16093,16 +15704,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setPacketAckFunc(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setPacketAckFunc",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setPacketAckFunc", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setPacketAckFunc" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__functionT_void_fstd__string_const_R_Gempa__CAPS__Time_const_R_Gempa__CAPS__Time_const_RF_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_boost__functionT_void_fstd__string_const_R_Gempa__CAPS__Time_const_R_Gempa__CAPS__Time_const_RF_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setPacketAckFunc" "', argument " "2"" of type '" "Gempa::CAPS::Plugin::PacketAckFunc const &""'"); } @@ -16126,16 +15736,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setSendTimeout(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setSendTimeout",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setSendTimeout", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setSendTimeout" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - 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 '" "Plugin_setSendTimeout" "', argument " "2"" of type '" "int""'"); } @@ -16148,7 +15757,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; int arg2 ; @@ -16159,22 +15768,19 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_0(PyObject *SWIGUNUSEDPARM(s int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOO:Plugin_setTimeouts",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setTimeouts" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - 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 '" "Plugin_setTimeouts" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "Plugin_setTimeouts" "', argument " "3"" of type '" "int""'"); } @@ -16187,7 +15793,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; int arg2 ; @@ -16201,28 +15807,24 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts__SWIG_1(PyObject *SWIGUNUSEDPARM(s int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOO:Plugin_setTimeouts",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setTimeouts" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - 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 '" "Plugin_setTimeouts" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "Plugin_setTimeouts" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "Plugin_setTimeouts" "', argument " "4"" of type '" "int""'"); } @@ -16240,13 +15842,9 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts(PyObject *self, PyObject *args) { PyObject *argv[5] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Plugin_setTimeouts", 0, 4, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -16263,7 +15861,7 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_setTimeouts__SWIG_0(self, args); + return _wrap_Plugin_setTimeouts__SWIG_0(self, argc, argv); } } } @@ -16289,7 +15887,7 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_setTimeouts__SWIG_1(self, args); + return _wrap_Plugin_setTimeouts__SWIG_1(self, argc, argv); } } } @@ -16297,7 +15895,7 @@ SWIGINTERN PyObject *_wrap_Plugin_setTimeouts(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Plugin_setTimeouts'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Plugin_setTimeouts'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Plugin::setTimeouts(int,int)\n" " Gempa::CAPS::Plugin::setTimeouts(int,int,int)\n"); @@ -16310,11 +15908,12 @@ SWIGINTERN PyObject *_wrap_Plugin_readJournal(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_readJournal",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_readJournal" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -16334,18 +15933,17 @@ SWIGINTERN PyObject *_wrap_Plugin_setJournal(PyObject *SWIGUNUSEDPARM(self), PyO void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setJournal",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setJournal", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setJournal" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setJournal" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16372,16 +15970,15 @@ SWIGINTERN PyObject *_wrap_Plugin_setFlushInterval(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_setFlushInterval",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Plugin_setFlushInterval", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setFlushInterval" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - 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 '" "Plugin_setFlushInterval" "', argument " "2"" of type '" "int""'"); } @@ -16399,11 +15996,12 @@ SWIGINTERN PyObject *_wrap_Plugin_streamStates(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Plugin::StreamStates *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_streamStates",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_streamStates" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); } @@ -16416,16 +16014,15 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_writeJournal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_writeJournal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_writeJournal",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_writeJournal" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -16438,7 +16035,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_writeJournal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_writeJournal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::ostream *arg2 = 0 ; @@ -16446,17 +16043,15 @@ SWIGINTERN PyObject *_wrap_Plugin_writeJournal__SWIG_1(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Plugin_writeJournal",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_writeJournal" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_writeJournal" "', argument " "2"" of type '" "std::ostream &""'"); } @@ -16477,20 +16072,16 @@ SWIGINTERN PyObject *_wrap_Plugin_writeJournal(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Plugin_writeJournal", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gempa__CAPS__Plugin, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Plugin_writeJournal__SWIG_0(self, args); + return _wrap_Plugin_writeJournal__SWIG_0(self, argc, argv); } } if (argc == 2) { @@ -16500,16 +16091,16 @@ SWIGINTERN PyObject *_wrap_Plugin_writeJournal(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Plugin_writeJournal__SWIG_1(self, args); + return _wrap_Plugin_writeJournal__SWIG_1(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Plugin_writeJournal'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Plugin_writeJournal'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Plugin::writeJournal()\n" " Gempa::CAPS::Plugin::writeJournal(std::ostream &)\n"); @@ -16517,7 +16108,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -16538,25 +16129,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P int res7 = SWIG_OLDOBJ ; int val8 ; int ecode8 = 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 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16567,7 +16150,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -16578,7 +16161,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -16589,7 +16172,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -16599,7 +16182,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P arg5 = ptr; } { - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::DataRecordPtr""'"); } @@ -16613,7 +16196,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res7 = SWIG_AsPtr_std_string(obj6, &ptr); + res7 = SWIG_AsPtr_std_string(swig_obj[6], &ptr); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Plugin_push" "', argument " "7"" of type '" "std::string const &""'"); } @@ -16622,7 +16205,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } arg7 = ptr; } - ecode8 = SWIG_AsVal_int(obj7, &val8); + ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "int""'"); } @@ -16645,7 +16228,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -16663,24 +16246,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P void *argp6 ; int res6 = 0 ; int res7 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16691,7 +16267,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -16702,7 +16278,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -16713,7 +16289,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -16723,7 +16299,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P arg5 = ptr; } { - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::DataRecordPtr""'"); } @@ -16737,7 +16313,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res7 = SWIG_AsPtr_std_string(obj6, &ptr); + res7 = SWIG_AsPtr_std_string(swig_obj[6], &ptr); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Plugin_push" "', argument " "7"" of type '" "std::string const &""'"); } @@ -16764,7 +16340,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -16799,30 +16375,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P int ecode12 = 0 ; int val13 ; int ecode13 = 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 * obj10 = 0 ; - PyObject * obj11 = 0 ; - PyObject * obj12 = 0 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 13) || (nobjs > 13)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16833,7 +16396,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -16844,7 +16407,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -16855,7 +16418,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -16864,7 +16427,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -16872,19 +16435,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_unsigned_SS_short(obj6, &val7); + ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "uint16_t""'"); } arg7 = static_cast< uint16_t >(val7); - ecode8 = SWIG_AsVal_unsigned_SS_short(obj7, &val8); + ecode8 = SWIG_AsVal_unsigned_SS_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "uint16_t""'"); } arg8 = static_cast< uint16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -16893,21 +16456,21 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P } arg9 = ptr; } - res10 = SWIG_ConvertPtr(obj9,SWIG_as_voidptrptr(&arg10), 0, 0); + res10 = SWIG_ConvertPtr(swig_obj[9],SWIG_as_voidptrptr(&arg10), 0, 0); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Plugin_push" "', argument " "10"" of type '" "void *""'"); } - ecode11 = SWIG_AsVal_size_t(obj10, &val11); + ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11); if (!SWIG_IsOK(ecode11)) { SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Plugin_push" "', argument " "11"" of type '" "size_t""'"); } arg11 = static_cast< size_t >(val11); - ecode12 = SWIG_AsVal_int(obj11, &val12); + ecode12 = SWIG_AsVal_int(swig_obj[11], &val12); if (!SWIG_IsOK(ecode12)) { SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Plugin_push" "', argument " "12"" of type '" "Gempa::CAPS::DataType""'"); } arg12 = static_cast< Gempa::CAPS::DataType >(val12); - ecode13 = SWIG_AsVal_int(obj12, &val13); + ecode13 = SWIG_AsVal_int(swig_obj[12], &val13); if (!SWIG_IsOK(ecode13)) { SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Plugin_push" "', argument " "13"" of type '" "int""'"); } @@ -16930,7 +16493,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -16962,29 +16525,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P int ecode11 = 0 ; int val12 ; int ecode12 = 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 * obj10 = 0 ; - PyObject * obj11 = 0 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 12) || (nobjs > 12)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -16995,7 +16546,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -17006,7 +16557,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -17017,7 +16568,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -17026,7 +16577,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -17034,19 +16585,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_unsigned_SS_short(obj6, &val7); + ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "uint16_t""'"); } arg7 = static_cast< uint16_t >(val7); - ecode8 = SWIG_AsVal_unsigned_SS_short(obj7, &val8); + ecode8 = SWIG_AsVal_unsigned_SS_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "uint16_t""'"); } arg8 = static_cast< uint16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -17055,16 +16606,16 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P } arg9 = ptr; } - res10 = SWIG_ConvertPtr(obj9,SWIG_as_voidptrptr(&arg10), 0, 0); + res10 = SWIG_ConvertPtr(swig_obj[9],SWIG_as_voidptrptr(&arg10), 0, 0); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Plugin_push" "', argument " "10"" of type '" "void *""'"); } - ecode11 = SWIG_AsVal_size_t(obj10, &val11); + ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11); if (!SWIG_IsOK(ecode11)) { SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Plugin_push" "', argument " "11"" of type '" "size_t""'"); } arg11 = static_cast< size_t >(val11); - ecode12 = SWIG_AsVal_int(obj11, &val12); + ecode12 = SWIG_AsVal_int(swig_obj[11], &val12); if (!SWIG_IsOK(ecode12)) { SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Plugin_push" "', argument " "12"" of type '" "Gempa::CAPS::DataType""'"); } @@ -17087,7 +16638,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -17118,28 +16669,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P int alloc10 = 0 ; size_t val11 ; int ecode11 = 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 * obj10 = 0 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 11) || (nobjs > 11)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -17150,7 +16690,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -17161,7 +16701,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -17172,7 +16712,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -17181,7 +16721,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -17189,19 +16729,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_unsigned_SS_short(obj6, &val7); + ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "uint16_t""'"); } arg7 = static_cast< uint16_t >(val7); - ecode8 = SWIG_AsVal_unsigned_SS_short(obj7, &val8); + ecode8 = SWIG_AsVal_unsigned_SS_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "uint16_t""'"); } arg8 = static_cast< uint16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -17210,12 +16750,12 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } arg9 = ptr; } - res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10); + res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Plugin_push" "', argument " "10"" of type '" "char *""'"); } arg10 = reinterpret_cast< char * >(buf10); - ecode11 = SWIG_AsVal_size_t(obj10, &val11); + ecode11 = SWIG_AsVal_size_t(swig_obj[10], &val11); if (!SWIG_IsOK(ecode11)) { SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Plugin_push" "', argument " "11"" of type '" "size_t""'"); } @@ -17240,7 +16780,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -17266,27 +16806,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P int ecode8 = 0 ; int res9 = SWIG_OLDOBJ ; int res10 = SWIG_OLDOBJ ; - 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 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 10) || (nobjs > 10)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -17297,7 +16827,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -17308,7 +16838,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -17319,7 +16849,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -17328,7 +16858,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -17336,19 +16866,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_unsigned_SS_short(obj6, &val7); + ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "uint16_t""'"); } arg7 = static_cast< uint16_t >(val7); - ecode8 = SWIG_AsVal_unsigned_SS_short(obj7, &val8); + ecode8 = SWIG_AsVal_unsigned_SS_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "uint16_t""'"); } arg8 = static_cast< uint16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -17359,7 +16889,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res10 = SWIG_AsPtr_std_string(obj9, &ptr); + res10 = SWIG_AsPtr_std_string(swig_obj[9], &ptr); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Plugin_push" "', argument " "10"" of type '" "std::string const &""'"); } @@ -17388,16 +16918,127 @@ fail: } +SWIGINTERN PyObject *_wrap_Plugin_flushEncoders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 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_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_flushEncoders" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + (arg1)->flushEncoders(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_dumpPackets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Plugin_dumpPackets", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_dumpPackets" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Plugin_dumpPackets" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->dumpPackets(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_packetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Gempa::CAPS::Plugin::PacketBuffer *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_packetBuffer" "', argument " "1"" of type '" "Gempa::CAPS::Plugin const *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + result = (Gempa::CAPS::Plugin::PacketBuffer *) &((Gempa::CAPS::Plugin const *)arg1)->packetBuffer(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Plugin_setAgent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; + std::string *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 = SWIG_OLDOBJ ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Plugin_setAgent", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_setAgent" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); + } + arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); + { + std::string *ptr = (std::string *)0; + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_setAgent" "', argument " "2"" of type '" "std::string const &""'"); + } + if (!ptr) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_setAgent" "', argument " "2"" of type '" "std::string const &""'"); + } + arg2 = ptr; + } + (arg1)->setAgent((std::string const &)*arg2); + resultobj = SWIG_Py_Void(); + if (SWIG_IsNewObj(res2)) delete arg2; + return resultobj; +fail: + if (SWIG_IsNewObj(res2)) delete arg2; + return NULL; +} + + SWIGINTERN PyObject *_wrap_Plugin_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Plugin_version",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_version" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } @@ -17410,7 +17051,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -17438,28 +17079,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P int res9 = SWIG_OLDOBJ ; int val11 ; int ecode11 = 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 * obj10 = 0 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 11) || (nobjs > 11)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -17470,7 +17100,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -17481,7 +17111,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -17492,7 +17122,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -17501,7 +17131,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -17509,19 +17139,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_short(obj6, &val7); + ecode7 = SWIG_AsVal_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "int16_t""'"); } arg7 = static_cast< int16_t >(val7); - ecode8 = SWIG_AsVal_short(obj7, &val8); + ecode8 = SWIG_AsVal_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "int16_t""'"); } arg8 = static_cast< int16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -17530,8 +17160,8 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } arg9 = ptr; } - arg10 = obj9; - ecode11 = SWIG_AsVal_int(obj10, &val11); + arg10 = swig_obj[9]; + ecode11 = SWIG_AsVal_int(swig_obj[10], &val11); if (!SWIG_IsOK(ecode11)) { SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Plugin_push" "', argument " "11"" of type '" "int""'"); } @@ -17554,7 +17184,7 @@ fail: } -SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::Plugin *arg1 = (Gempa::CAPS::Plugin *) 0 ; std::string *arg2 = 0 ; @@ -17579,27 +17209,17 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P unsigned short val8 ; int ecode8 = 0 ; int res9 = SWIG_OLDOBJ ; - 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 ; Gempa::CAPS::Plugin::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Plugin_push",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); + if ((nobjs < 10) || (nobjs > 10)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Plugin, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Plugin_push" "', argument " "1"" of type '" "Gempa::CAPS::Plugin *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Plugin * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Plugin_push" "', argument " "2"" of type '" "std::string const &""'"); } @@ -17610,7 +17230,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Plugin_push" "', argument " "3"" of type '" "std::string const &""'"); } @@ -17621,7 +17241,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res4 = SWIG_AsPtr_std_string(obj3, &ptr); + res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Plugin_push" "', argument " "4"" of type '" "std::string const &""'"); } @@ -17632,7 +17252,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P } { std::string *ptr = (std::string *)0; - res5 = SWIG_AsPtr_std_string(obj4, &ptr); + res5 = SWIG_AsPtr_std_string(swig_obj[4], &ptr); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Plugin_push" "', argument " "5"" of type '" "std::string const &""'"); } @@ -17641,7 +17261,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P } arg5 = ptr; } - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -17649,19 +17269,19 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Plugin_push" "', argument " "6"" of type '" "Gempa::CAPS::Time const &""'"); } arg6 = reinterpret_cast< Gempa::CAPS::Time * >(argp6); - ecode7 = SWIG_AsVal_unsigned_SS_short(obj6, &val7); + ecode7 = SWIG_AsVal_unsigned_SS_short(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Plugin_push" "', argument " "7"" of type '" "uint16_t""'"); } arg7 = static_cast< uint16_t >(val7); - ecode8 = SWIG_AsVal_unsigned_SS_short(obj7, &val8); + ecode8 = SWIG_AsVal_unsigned_SS_short(swig_obj[7], &val8); if (!SWIG_IsOK(ecode8)) { SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Plugin_push" "', argument " "8"" of type '" "uint16_t""'"); } arg8 = static_cast< uint16_t >(val8); { std::string *ptr = (std::string *)0; - res9 = SWIG_AsPtr_std_string(obj8, &ptr); + res9 = SWIG_AsPtr_std_string(swig_obj[8], &ptr); if (!SWIG_IsOK(res9)) { SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Plugin_push" "', argument " "9"" of type '" "std::string const &""'"); } @@ -17670,7 +17290,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push__SWIG_7(PyObject *SWIGUNUSEDPARM(self), P } arg9 = ptr; } - arg10 = obj9; + arg10 = swig_obj[9]; result = (Gempa::CAPS::Plugin::Status)Gempa_CAPS_Plugin_push__SWIG_7(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,(Gempa::CAPS::Time const &)*arg6,arg7,arg8,(std::string const &)*arg9,arg10); resultobj = SWIG_From_int(static_cast< int >(result)); if (SWIG_IsNewObj(res2)) delete arg2; @@ -17694,13 +17314,9 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { PyObject *argv[14] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 13) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "Plugin_push", 0, 13, argv))) SWIG_fail; + --argc; if (argc == 7) { int _v; void *vptr = 0; @@ -17719,13 +17335,13 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Plugin_push__SWIG_1(self, args); + return _wrap_Plugin_push__SWIG_1(self, argc, argv); } } } @@ -17752,7 +17368,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_boost__shared_ptrT_Gempa__CAPS__DataRecord_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0)); @@ -17763,7 +17379,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_push__SWIG_0(self, args); + return _wrap_Plugin_push__SWIG_0(self, argc, argv); } } } @@ -17791,7 +17407,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -17810,7 +17426,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Plugin_push__SWIG_5(self, args); + return _wrap_Plugin_push__SWIG_5(self, argc, argv); } } } @@ -17840,7 +17456,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -17858,7 +17474,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { if (_v) { _v = (argv[9] != 0); if (_v) { - return _wrap_Plugin_push__SWIG_7(self, args); + return _wrap_Plugin_push__SWIG_7(self, argc, argv); } } } @@ -17888,7 +17504,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -17912,7 +17528,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_push__SWIG_4(self, args); + return _wrap_Plugin_push__SWIG_4(self, argc, argv); } } } @@ -17943,7 +17559,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -17966,7 +17582,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_push__SWIG_6(self, args); + return _wrap_Plugin_push__SWIG_6(self, argc, argv); } } } @@ -17997,7 +17613,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -18027,7 +17643,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_push__SWIG_3(self, args); + return _wrap_Plugin_push__SWIG_3(self, argc, argv); } } } @@ -18059,7 +17675,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -18094,7 +17710,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Plugin_push__SWIG_2(self, args); + return _wrap_Plugin_push__SWIG_2(self, argc, argv); } } } @@ -18111,7 +17727,7 @@ SWIGINTERN PyObject *_wrap_Plugin_push(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Plugin_push'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Plugin_push'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::Plugin::push(std::string const &,std::string const &,std::string const &,std::string const &,Gempa::CAPS::DataRecordPtr,std::string const &,int)\n" " Gempa::CAPS::Plugin::push(std::string const &,std::string const &,std::string const &,std::string const &,Gempa::CAPS::DataRecordPtr,std::string const &)\n" @@ -18127,11 +17743,15 @@ fail: SWIGINTERN PyObject *Plugin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Plugin, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *Plugin_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_RawResponseHeader_timeSeconds_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RawResponseHeader *arg1 = (Gempa::CAPS::RawResponseHeader *) 0 ; @@ -18140,16 +17760,15 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_timeSeconds_set(PyObject *SWIGUNUSE int res1 = 0 ; long long val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawResponseHeader_timeSeconds_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawResponseHeader_timeSeconds_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_timeSeconds_set" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawResponseHeader * >(argp1); - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + ecode2 = SWIG_AsVal_long_SS_long(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawResponseHeader_timeSeconds_set" "', argument " "2"" of type '" "int64_t""'"); } @@ -18167,11 +17786,12 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_timeSeconds_get(PyObject *SWIGUNUSE Gempa::CAPS::RawResponseHeader *arg1 = (Gempa::CAPS::RawResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int64_t result; - if (!PyArg_ParseTuple(args,(char *)"O:RawResponseHeader_timeSeconds_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_timeSeconds_get" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } @@ -18192,16 +17812,15 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_timeMicroSeconds_set(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawResponseHeader_timeMicroSeconds_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawResponseHeader_timeMicroSeconds_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_timeMicroSeconds_set" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawResponseHeader * >(argp1); - 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 '" "RawResponseHeader_timeMicroSeconds_set" "', argument " "2"" of type '" "int32_t""'"); } @@ -18219,11 +17838,12 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_timeMicroSeconds_get(PyObject *SWIG Gempa::CAPS::RawResponseHeader *arg1 = (Gempa::CAPS::RawResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int32_t result; - if (!PyArg_ParseTuple(args,(char *)"O:RawResponseHeader_timeMicroSeconds_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_timeMicroSeconds_get" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } @@ -18244,17 +17864,16 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_get(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:RawResponseHeader_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawResponseHeader_get", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawResponseHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawResponseHeader_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18275,11 +17894,12 @@ SWIGINTERN PyObject *_wrap_RawResponseHeader_dataSize(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::RawResponseHeader *arg1 = (Gempa::CAPS::RawResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:RawResponseHeader_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawResponseHeader_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader const *""'"); } @@ -18296,7 +17916,7 @@ SWIGINTERN PyObject *_wrap_new_RawResponseHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *resultobj = 0; Gempa::CAPS::RawResponseHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_RawResponseHeader")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_RawResponseHeader", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RawResponseHeader *)new Gempa::CAPS::RawResponseHeader(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -18310,10 +17930,11 @@ SWIGINTERN PyObject *_wrap_delete_RawResponseHeader(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::RawResponseHeader *arg1 = (Gempa::CAPS::RawResponseHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_RawResponseHeader",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawResponseHeader" "', argument " "1"" of type '" "Gempa::CAPS::RawResponseHeader *""'"); } @@ -18328,21 +17949,26 @@ fail: SWIGINTERN PyObject *RawResponseHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RawResponseHeader, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *RawResponseHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_RawDataRecord_formatName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18375,21 +18001,16 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s 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[6] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:RawDataRecord_readMetaData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_readMetaData", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_readMetaData" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18397,12 +18018,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_readMetaData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } @@ -18410,7 +18031,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } @@ -18418,7 +18039,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_readMetaData(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RawDataRecord_readMetaData" "', argument " "6"" of type '" "Gempa::CAPS::Time &""'"); } @@ -18442,16 +18063,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_setHeader(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawDataRecord_setHeader",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_setHeader", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_setHeader" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_setHeader" "', argument " "2"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } @@ -18472,11 +18092,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_header(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_header" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18494,11 +18115,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_startTime(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_startTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_startTime" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18516,11 +18138,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_endTime(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_endTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_endTime" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18538,11 +18161,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_canTrim(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18560,11 +18184,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_canMerge(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -18588,18 +18213,16 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RawDataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18607,7 +18230,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_trim(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RawDataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18631,17 +18254,16 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_dataSize(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"OO:RawDataRecord_dataSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_dataSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawDataRecord_dataSize" "', argument " "2"" of type '" "bool""'"); } @@ -18654,7 +18276,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -18674,21 +18296,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:RawDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18696,12 +18312,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18709,7 +18325,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18717,7 +18333,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RawDataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -18730,7 +18346,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -18747,20 +18363,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:RawDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18768,12 +18379,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18781,7 +18392,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18797,7 +18408,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -18811,19 +18422,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(se int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:RawDataRecord_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18831,12 +18438,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -18852,7 +18459,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -18863,18 +18470,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RawDataRecord_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -18882,7 +18486,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_get" "', argument " "3"" of type '" "int""'"); } @@ -18900,13 +18504,9 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "RawDataRecord_get", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -18914,7 +18514,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -18922,7 +18522,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_RawDataRecord_get__SWIG_3(self, args); + return _wrap_RawDataRecord_get__SWIG_3(self, argc, argv); } } } @@ -18934,7 +18534,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -18942,10 +18542,10 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RawDataRecord_get__SWIG_2(self, args); + return _wrap_RawDataRecord_get__SWIG_2(self, argc, argv); } } } @@ -18958,7 +18558,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -18966,13 +18566,13 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RawDataRecord_get__SWIG_1(self, args); + return _wrap_RawDataRecord_get__SWIG_1(self, argc, argv); } } } @@ -18986,7 +18586,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -18994,10 +18594,10 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -19005,7 +18605,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_RawDataRecord_get__SWIG_0(self, args); + return _wrap_RawDataRecord_get__SWIG_0(self, argc, argv); } } } @@ -19015,7 +18615,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RawDataRecord_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawDataRecord_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::RawDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::RawDataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n" @@ -19025,7 +18625,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -19045,21 +18645,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPAR int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:RawDataRecord_getData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_getData" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19067,12 +18661,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_getData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_getData" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19080,7 +18674,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawDataRecord_getData" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19088,7 +18682,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RawDataRecord_getData" "', argument " "6"" of type '" "int""'"); } @@ -19101,7 +18695,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -19118,20 +18712,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_1(PyObject *SWIGUNUSEDPAR int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:RawDataRecord_getData",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_getData" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19139,12 +18728,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_getData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_getData" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19152,7 +18741,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RawDataRecord_getData" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19168,7 +18757,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -19182,19 +18771,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_2(PyObject *SWIGUNUSEDPAR int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:RawDataRecord_getData",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_getData" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19202,12 +18787,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_2(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_getData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RawDataRecord_getData" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19223,7 +18808,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -19234,18 +18819,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_3(PyObject *SWIGUNUSEDPAR int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RawDataRecord_getData",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_getData" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19253,7 +18835,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData__SWIG_3(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_getData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RawDataRecord_getData" "', argument " "3"" of type '" "int""'"); } @@ -19271,13 +18853,9 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "RawDataRecord_getData", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 3) { int _v; void *vptr = 0; @@ -19285,7 +18863,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -19293,7 +18871,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_RawDataRecord_getData__SWIG_3(self, args); + return _wrap_RawDataRecord_getData__SWIG_3(self, argc, argv); } } } @@ -19305,7 +18883,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -19313,10 +18891,10 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RawDataRecord_getData__SWIG_2(self, args); + return _wrap_RawDataRecord_getData__SWIG_2(self, argc, argv); } } } @@ -19329,7 +18907,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -19337,13 +18915,13 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RawDataRecord_getData__SWIG_1(self, args); + return _wrap_RawDataRecord_getData__SWIG_1(self, argc, argv); } } } @@ -19357,7 +18935,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -19365,10 +18943,10 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -19376,7 +18954,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_RawDataRecord_getData__SWIG_0(self, args); + return _wrap_RawDataRecord_getData__SWIG_0(self, argc, argv); } } } @@ -19386,7 +18964,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_getData(PyObject *self, PyObject *args) } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RawDataRecord_getData'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RawDataRecord_getData'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::RawDataRecord::getData(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::RawDataRecord::getData(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n" @@ -19407,18 +18985,16 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_put(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; bool val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RawDataRecord_put",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_put", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19426,7 +19002,7 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_put(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RawDataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawDataRecord_put" "', argument " "3"" of type '" "bool""'"); } @@ -19444,11 +19020,12 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_packetType(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:RawDataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord const *""'"); } @@ -19469,16 +19046,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_setStartTime(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawDataRecord_setStartTime",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_setStartTime", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_setStartTime" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_setStartTime" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19505,22 +19081,20 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_setSamplingFrequency(PyObject *SWIGUNUS int ecode2 = 0 ; unsigned short val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; - if (!PyArg_ParseTuple(args,(char *)"OOO:RawDataRecord_setSamplingFrequency",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_setSamplingFrequency", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_setSamplingFrequency" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RawDataRecord_setSamplingFrequency" "', argument " "2"" of type '" "uint16_t""'"); } arg2 = static_cast< uint16_t >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawDataRecord_setSamplingFrequency" "', argument " "3"" of type '" "uint16_t""'"); } @@ -19541,16 +19115,15 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_setDataType(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RawDataRecord_setDataType",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_setDataType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_setDataType" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - 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 '" "RawDataRecord_setDataType" "', argument " "2"" of type '" "Gempa::CAPS::DataType""'"); } @@ -19573,21 +19146,19 @@ SWIGINTERN PyObject *_wrap_RawDataRecord_setBuffer(PyObject *SWIGUNUSEDPARM(self int res2 ; 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:RawDataRecord_setBuffer",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RawDataRecord_setBuffer", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RawDataRecord_setBuffer" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RawDataRecord_setBuffer" "', argument " "2"" of type '" "void const *""'"); } - ecode3 = SWIG_AsVal_size_t(obj2, &val3); + ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RawDataRecord_setBuffer" "', argument " "3"" of type '" "size_t""'"); } @@ -19605,10 +19176,11 @@ SWIGINTERN PyObject *_wrap_delete_RawDataRecord(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RawDataRecord *arg1 = (Gempa::CAPS::RawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_RawDataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RawDataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RawDataRecord" "', argument " "1"" of type '" "Gempa::CAPS::RawDataRecord *""'"); } @@ -19623,7 +19195,7 @@ fail: SWIGINTERN PyObject *RawDataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RawDataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -19633,11 +19205,12 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_canTrim(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::FixedRawDataRecord *arg1 = (Gempa::CAPS::FixedRawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:FixedRawDataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord const *""'"); } @@ -19655,11 +19228,12 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_canMerge(PyObject *SWIGUNUSEDPARM( Gempa::CAPS::FixedRawDataRecord *arg1 = (Gempa::CAPS::FixedRawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:FixedRawDataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord const *""'"); } @@ -19683,18 +19257,16 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_trim(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:FixedRawDataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FixedRawDataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::FixedRawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedRawDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19702,7 +19274,7 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_trim(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRawDataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedRawDataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19723,11 +19295,12 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_formatName(PyObject *SWIGUNUSEDPAR Gempa::CAPS::FixedRawDataRecord *arg1 = (Gempa::CAPS::FixedRawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:FixedRawDataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord const *""'"); } @@ -19760,21 +19333,16 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_get(PyObject *SWIGUNUSEDPARM(self) int res5 = 0 ; int 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[6] ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FixedRawDataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FixedRawDataRecord_get", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::FixedRawDataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedRawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -19782,12 +19350,12 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_get(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRawDataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "FixedRawDataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedRawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19795,7 +19363,7 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_get(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRawDataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedRawDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -19803,7 +19371,7 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_get(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedRawDataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FixedRawDataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -19821,11 +19389,12 @@ SWIGINTERN PyObject *_wrap_FixedRawDataRecord_packetType(PyObject *SWIGUNUSEDPAR Gempa::CAPS::FixedRawDataRecord *arg1 = (Gempa::CAPS::FixedRawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:FixedRawDataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedRawDataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord const *""'"); } @@ -19843,10 +19412,11 @@ SWIGINTERN PyObject *_wrap_delete_FixedRawDataRecord(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::FixedRawDataRecord *arg1 = (Gempa::CAPS::FixedRawDataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_FixedRawDataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedRawDataRecord" "', argument " "1"" of type '" "Gempa::CAPS::FixedRawDataRecord *""'"); } @@ -19861,7 +19431,7 @@ fail: SWIGINTERN PyObject *FixedRawDataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__FixedRawDataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -19874,16 +19444,15 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_chunkSize_set(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_chunkSize_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_chunkSize_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_chunkSize_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - 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 '" "ChunkHeader_chunkSize_set" "', argument " "2"" of type '" "int""'"); } @@ -19901,11 +19470,12 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_chunkSize_get(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::RIFF::ChunkHeader *arg1 = (Gempa::CAPS::RIFF::ChunkHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkHeader_chunkSize_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_chunkSize_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } @@ -19927,17 +19497,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_setChunkType(PyObject *SWIGUNUSEDPARM(sel int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_setChunkType",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_setChunkType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_setChunkType" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - 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 '" "ChunkHeader_setChunkType" "', argument " "2"" of type '" "char const *""'"); } @@ -19961,17 +19530,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_isChunkType(PyObject *SWIGUNUSEDPARM(self int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_isChunkType",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_isChunkType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_isChunkType" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - 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 '" "ChunkHeader_isChunkType" "', argument " "2"" of type '" "char const *""'"); } @@ -19991,11 +19559,12 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_validChunkType(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::RIFF::ChunkHeader *arg1 = (Gempa::CAPS::RIFF::ChunkHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkHeader_validChunkType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_validChunkType" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader const *""'"); } @@ -20013,11 +19582,12 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_dataSize(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RIFF::ChunkHeader *arg1 = (Gempa::CAPS::RIFF::ChunkHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkHeader_dataSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader const *""'"); } @@ -20038,17 +19608,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_read(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_read",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_read", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_read" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkHeader_read" "', argument " "2"" of type '" "std::istream &""'"); } @@ -20072,17 +19641,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_write(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_write",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_write", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_write" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkHeader_write" "', argument " "2"" of type '" "std::ostream &""'"); } @@ -20106,17 +19674,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_get(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_get",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_get", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkHeader_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20140,17 +19707,16 @@ SWIGINTERN PyObject *_wrap_ChunkHeader_put(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkHeader_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ChunkHeader_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkHeader_put" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkHeader * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkHeader_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20170,7 +19736,7 @@ SWIGINTERN PyObject *_wrap_new_ChunkHeader(PyObject *SWIGUNUSEDPARM(self), PyObj PyObject *resultobj = 0; Gempa::CAPS::RIFF::ChunkHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_ChunkHeader")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_ChunkHeader", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RIFF::ChunkHeader *)new Gempa::CAPS::RIFF::ChunkHeader(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -20184,10 +19750,11 @@ SWIGINTERN PyObject *_wrap_delete_ChunkHeader(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::RIFF::ChunkHeader *arg1 = (Gempa::CAPS::RIFF::ChunkHeader *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_ChunkHeader",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChunkHeader" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkHeader *""'"); } @@ -20202,11 +19769,15 @@ fail: SWIGINTERN PyObject *ChunkHeader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkHeader, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *ChunkHeader_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN int Swig_var_ChunkHeaderSize_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable ChunkHeaderSize is read-only."); return 1; @@ -20221,11 +19792,11 @@ SWIGINTERN PyObject *Swig_var_ChunkHeaderSize_get(void) { } -SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::ChunkIterator *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_ChunkIterator")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::RIFF::ChunkIterator *)new Gempa::CAPS::RIFF::ChunkIterator(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -20234,17 +19805,16 @@ fail: } -SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; Gempa::CAPS::RIFF::ChunkIterator *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ChunkIterator",&obj0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChunkIterator" "', argument " "1"" of type '" "std::string const &""'"); } @@ -20263,16 +19833,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ChunkIterator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::istream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::RIFF::ChunkIterator *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_ChunkIterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__istream, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChunkIterator" "', argument " "1"" of type '" "std::istream &""'"); } @@ -20293,23 +19862,19 @@ SWIGINTERN PyObject *_wrap_new_ChunkIterator(PyObject *self, PyObject *args) { PyObject *argv[2] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ChunkIterator", 0, 1, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_ChunkIterator__SWIG_0(self, args); + return _wrap_new_ChunkIterator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ChunkIterator__SWIG_2(self, args); + return _wrap_new_ChunkIterator__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -20317,12 +19882,12 @@ SWIGINTERN PyObject *_wrap_new_ChunkIterator(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ChunkIterator__SWIG_1(self, args); + return _wrap_new_ChunkIterator__SWIG_1(self, argc, argv); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ChunkIterator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ChunkIterator'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::RIFF::ChunkIterator::ChunkIterator()\n" " Gempa::CAPS::RIFF::ChunkIterator::ChunkIterator(std::string const &)\n" @@ -20331,25 +19896,23 @@ fail: } -SWIGINTERN PyObject *_wrap_ChunkIterator_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ChunkIterator_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; std::string *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkIterator_begin",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_begin" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkIterator * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkIterator_begin" "', argument " "2"" of type '" "std::string const &""'"); } @@ -20368,7 +19931,7 @@ fail: } -SWIGINTERN PyObject *_wrap_ChunkIterator_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ChunkIterator_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; std::istream *arg2 = 0 ; @@ -20376,16 +19939,14 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_begin__SWIG_1(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:ChunkIterator_begin",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_begin" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::ChunkIterator * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ChunkIterator_begin" "', argument " "2"" of type '" "std::istream &""'"); } @@ -20406,13 +19967,9 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_begin(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "ChunkIterator_begin", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; @@ -20420,10 +19977,10 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_begin(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ChunkIterator_begin__SWIG_1(self, args); + return _wrap_ChunkIterator_begin__SWIG_1(self, argc, argv); } } } @@ -20436,13 +19993,13 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_begin(PyObject *self, PyObject *args) { int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ChunkIterator_begin__SWIG_0(self, args); + return _wrap_ChunkIterator_begin__SWIG_0(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ChunkIterator_begin'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ChunkIterator_begin'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::RIFF::ChunkIterator::begin(std::string const &)\n" " Gempa::CAPS::RIFF::ChunkIterator::begin(std::istream &)\n"); @@ -20455,11 +20012,12 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_next(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkIterator_next",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_next" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator *""'"); } @@ -20477,11 +20035,12 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_header(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::RIFF::ChunkHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkIterator_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_header" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator const *""'"); } @@ -20499,11 +20058,12 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_headerPos(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkIterator_headerPos",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_headerPos" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator const *""'"); } @@ -20521,11 +20081,12 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_contentPos(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkIterator_contentPos",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_contentPos" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator const *""'"); } @@ -20543,11 +20104,12 @@ SWIGINTERN PyObject *_wrap_ChunkIterator_istream(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::istream *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:ChunkIterator_istream",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChunkIterator_istream" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator const *""'"); } @@ -20565,10 +20127,11 @@ SWIGINTERN PyObject *_wrap_delete_ChunkIterator(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RIFF::ChunkIterator *arg1 = (Gempa::CAPS::RIFF::ChunkIterator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_ChunkIterator",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChunkIterator" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::ChunkIterator *""'"); } @@ -20583,20 +20146,25 @@ fail: SWIGINTERN PyObject *ChunkIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__ChunkIterator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *ChunkIterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_delete_Chunk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::Chunk *arg1 = (Gempa::CAPS::RIFF::Chunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Chunk",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Chunk" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk *""'"); } @@ -20620,18 +20188,16 @@ SWIGINTERN PyObject *_wrap_Chunk_read(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Chunk_read",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Chunk_read", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Chunk_read" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::Chunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Chunk_read" "', argument " "2"" of type '" "std::istream &""'"); } @@ -20639,7 +20205,7 @@ SWIGINTERN PyObject *_wrap_Chunk_read(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Chunk_read" "', argument " "2"" of type '" "std::istream &""'"); } arg2 = reinterpret_cast< std::istream * >(argp2); - 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 '" "Chunk_read" "', argument " "3"" of type '" "int""'"); } @@ -20660,17 +20226,16 @@ SWIGINTERN PyObject *_wrap_Chunk_write(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Chunk_write",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Chunk_write", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Chunk_write" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::Chunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Chunk_write" "', argument " "2"" of type '" "std::ostream &""'"); } @@ -20697,18 +20262,16 @@ SWIGINTERN PyObject *_wrap_Chunk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Chunk_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Chunk_get", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Chunk_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::Chunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Chunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20716,7 +20279,7 @@ SWIGINTERN PyObject *_wrap_Chunk_get(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Chunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "Chunk_get" "', argument " "3"" of type '" "int""'"); } @@ -20737,17 +20300,16 @@ SWIGINTERN PyObject *_wrap_Chunk_put(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:Chunk_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Chunk_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Chunk_put" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::Chunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Chunk_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20768,11 +20330,12 @@ SWIGINTERN PyObject *_wrap_Chunk_chunkSize(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::RIFF::Chunk *arg1 = (Gempa::CAPS::RIFF::Chunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Chunk_chunkSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Chunk_chunkSize" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::Chunk const *""'"); } @@ -20787,7 +20350,7 @@ fail: SWIGINTERN PyObject *Chunk_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__Chunk, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -20800,16 +20363,15 @@ SWIGINTERN PyObject *_wrap_HeadChunk_data_set(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:HeadChunk_data_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "HeadChunk_data_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeadChunk_data_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::HeadChunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_Gempa__CAPS__PacketDataHeader, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeadChunk_data_set" "', argument " "2"" of type '" "Gempa::CAPS::PacketDataHeader *""'"); } @@ -20827,11 +20389,12 @@ SWIGINTERN PyObject *_wrap_HeadChunk_data_get(PyObject *SWIGUNUSEDPARM(self), Py Gempa::CAPS::RIFF::HeadChunk *arg1 = (Gempa::CAPS::RIFF::HeadChunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketDataHeader *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:HeadChunk_data_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeadChunk_data_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk *""'"); } @@ -20849,11 +20412,12 @@ SWIGINTERN PyObject *_wrap_HeadChunk_chunkSize(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::RIFF::HeadChunk *arg1 = (Gempa::CAPS::RIFF::HeadChunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:HeadChunk_chunkSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeadChunk_chunkSize" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk const *""'"); } @@ -20877,18 +20441,16 @@ SWIGINTERN PyObject *_wrap_HeadChunk_get(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:HeadChunk_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "HeadChunk_get", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeadChunk_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::HeadChunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeadChunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20896,7 +20458,7 @@ SWIGINTERN PyObject *_wrap_HeadChunk_get(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeadChunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "HeadChunk_get" "', argument " "3"" of type '" "int""'"); } @@ -20917,17 +20479,16 @@ SWIGINTERN PyObject *_wrap_HeadChunk_put(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:HeadChunk_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "HeadChunk_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeadChunk_put" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::HeadChunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeadChunk_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -20947,7 +20508,7 @@ SWIGINTERN PyObject *_wrap_new_HeadChunk(PyObject *SWIGUNUSEDPARM(self), PyObjec PyObject *resultobj = 0; Gempa::CAPS::RIFF::HeadChunk *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_HeadChunk")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_HeadChunk", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RIFF::HeadChunk *)new Gempa::CAPS::RIFF::HeadChunk(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -20961,10 +20522,11 @@ SWIGINTERN PyObject *_wrap_delete_HeadChunk(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::RIFF::HeadChunk *arg1 = (Gempa::CAPS::RIFF::HeadChunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_HeadChunk",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeadChunk" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::HeadChunk *""'"); } @@ -20979,11 +20541,15 @@ fail: SWIGINTERN PyObject *HeadChunk_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__HeadChunk, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *HeadChunk_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_SID_networkCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; @@ -20991,18 +20557,17 @@ SWIGINTERN PyObject *_wrap_SID_networkCode_set(PyObject *SWIGUNUSEDPARM(self), P void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SID_networkCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID_networkCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_networkCode_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID_networkCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -21026,11 +20591,12 @@ SWIGINTERN PyObject *_wrap_SID_networkCode_get(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SID_networkCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_networkCode_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } @@ -21050,18 +20616,17 @@ SWIGINTERN PyObject *_wrap_SID_stationCode_set(PyObject *SWIGUNUSEDPARM(self), P void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SID_stationCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID_stationCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_stationCode_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID_stationCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -21085,11 +20650,12 @@ SWIGINTERN PyObject *_wrap_SID_stationCode_get(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SID_stationCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_stationCode_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } @@ -21109,18 +20675,17 @@ SWIGINTERN PyObject *_wrap_SID_locationCode_set(PyObject *SWIGUNUSEDPARM(self), void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SID_locationCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID_locationCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_locationCode_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID_locationCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -21144,11 +20709,12 @@ SWIGINTERN PyObject *_wrap_SID_locationCode_get(PyObject *SWIGUNUSEDPARM(self), Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SID_locationCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_locationCode_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } @@ -21168,18 +20734,17 @@ SWIGINTERN PyObject *_wrap_SID_channelCode_set(PyObject *SWIGUNUSEDPARM(self), P void *argp1 = 0 ; int res1 = 0 ; int res2 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:SID_channelCode_set",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID_channelCode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_channelCode_set" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID_channelCode_set" "', argument " "2"" of type '" "std::string const &""'"); } @@ -21203,11 +20768,12 @@ SWIGINTERN PyObject *_wrap_SID_channelCode_get(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SID_channelCode_get",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_channelCode_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } @@ -21228,17 +20794,16 @@ SWIGINTERN PyObject *_wrap_SID___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SID___eq__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID___eq__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID___eq__" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID___eq__" "', argument " "2"" of type '" "Gempa::CAPS::RIFF::SID const &""'"); } @@ -21250,7 +20815,9 @@ SWIGINTERN PyObject *_wrap_SID___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject * resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -21262,17 +20829,16 @@ SWIGINTERN PyObject *_wrap_SID___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SID___ne__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SID___ne__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID___ne__" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SID * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SID___ne__" "', argument " "2"" of type '" "Gempa::CAPS::RIFF::SID const &""'"); } @@ -21284,7 +20850,9 @@ SWIGINTERN PyObject *_wrap_SID___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject * resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: - return NULL; + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } @@ -21293,11 +20861,12 @@ SWIGINTERN PyObject *_wrap_SID_toString(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"O:SID_toString",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SID_toString" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID const *""'"); } @@ -21314,7 +20883,7 @@ SWIGINTERN PyObject *_wrap_new_SID(PyObject *SWIGUNUSEDPARM(self), PyObject *arg PyObject *resultobj = 0; Gempa::CAPS::RIFF::SID *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_SID")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_SID", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RIFF::SID *)new Gempa::CAPS::RIFF::SID(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RIFF__SID, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -21328,10 +20897,11 @@ SWIGINTERN PyObject *_wrap_delete_SID(PyObject *SWIGUNUSEDPARM(self), PyObject * Gempa::CAPS::RIFF::SID *arg1 = (Gempa::CAPS::RIFF::SID *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SID",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SID, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SID" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SID *""'"); } @@ -21346,21 +20916,26 @@ fail: SWIGINTERN PyObject *SID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__SID, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *SID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_SIDChunk_chunkSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RIFF::SIDChunk *arg1 = (Gempa::CAPS::RIFF::SIDChunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:SIDChunk_chunkSize",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIDChunk_chunkSize" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SIDChunk const *""'"); } @@ -21384,18 +20959,16 @@ SWIGINTERN PyObject *_wrap_SIDChunk_get(PyObject *SWIGUNUSEDPARM(self), PyObject int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SIDChunk_get",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SIDChunk_get", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIDChunk_get" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SIDChunk *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SIDChunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIDChunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -21403,7 +20976,7 @@ SWIGINTERN PyObject *_wrap_SIDChunk_get(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIDChunk_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "SIDChunk_get" "', argument " "3"" of type '" "int""'"); } @@ -21424,17 +20997,16 @@ SWIGINTERN PyObject *_wrap_SIDChunk_put(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:SIDChunk_put",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SIDChunk_put", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIDChunk_put" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SIDChunk const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RIFF::SIDChunk * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIDChunk_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -21454,7 +21026,7 @@ SWIGINTERN PyObject *_wrap_new_SIDChunk(PyObject *SWIGUNUSEDPARM(self), PyObject PyObject *resultobj = 0; Gempa::CAPS::RIFF::SIDChunk *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_SIDChunk")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_SIDChunk", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::RIFF::SIDChunk *)new Gempa::CAPS::RIFF::SIDChunk(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -21468,10 +21040,11 @@ SWIGINTERN PyObject *_wrap_delete_SIDChunk(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::RIFF::SIDChunk *arg1 = (Gempa::CAPS::RIFF::SIDChunk *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SIDChunk",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIDChunk" "', argument " "1"" of type '" "Gempa::CAPS::RIFF::SIDChunk *""'"); } @@ -21486,21 +21059,26 @@ fail: SWIGINTERN PyObject *SIDChunk_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RIFF__SIDChunk, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *SIDChunk_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_RTCM2DataRecord_formatName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_formatName",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_formatName" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21521,16 +21099,15 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_setTimeStamp(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:RTCM2DataRecord_setTimeStamp",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_setTimeStamp", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_setTimeStamp" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_setTimeStamp" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21557,22 +21134,20 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_setSamplingFrequency(PyObject *SWIGUN int ecode2 = 0 ; unsigned short val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; - if (!PyArg_ParseTuple(args,(char *)"OOO:RTCM2DataRecord_setSamplingFrequency",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_setSamplingFrequency", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_setSamplingFrequency" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2); + ecode2 = SWIG_AsVal_unsigned_SS_short(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTCM2DataRecord_setSamplingFrequency" "', argument " "2"" of type '" "uint16_t""'"); } arg2 = static_cast< uint16_t >(val2); - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RTCM2DataRecord_setSamplingFrequency" "', argument " "3"" of type '" "uint16_t""'"); } @@ -21605,21 +21180,16 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM 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[6] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:RTCM2DataRecord_readMetaData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_readMetaData", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_readMetaData" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -21627,12 +21197,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_readMetaData" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RTCM2DataRecord_readMetaData" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RTCM2DataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } @@ -21640,7 +21210,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_readMetaData" "', argument " "4"" of type '" "Gempa::CAPS::DataRecord::Header &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RTCM2DataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } @@ -21648,7 +21218,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_readMetaData(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_readMetaData" "', argument " "5"" of type '" "Gempa::CAPS::Time &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_Gempa__CAPS__Time, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RTCM2DataRecord_readMetaData" "', argument " "6"" of type '" "Gempa::CAPS::Time &""'"); } @@ -21669,11 +21239,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_header(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::DataRecord::Header *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_header",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_header" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21691,11 +21262,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_startTime(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_startTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_startTime" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21713,11 +21285,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_endTime(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_endTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_endTime" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21735,11 +21308,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_canTrim(PyObject *SWIGUNUSEDPARM(self Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_canTrim",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_canTrim" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21757,11 +21331,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_canMerge(PyObject *SWIGUNUSEDPARM(sel Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_canMerge",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_canMerge" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -21785,18 +21360,16 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_trim(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RTCM2DataRecord_trim",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_trim", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_trim" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21804,7 +21377,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_trim(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_trim" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } arg2 = reinterpret_cast< Gempa::CAPS::Time * >(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RTCM2DataRecord_trim" "', argument " "3"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21828,17 +21401,16 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_dataSize(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; size_t result; - if (!PyArg_ParseTuple(args,(char *)"OO:RTCM2DataRecord_dataSize",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_dataSize", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_dataSize" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTCM2DataRecord_dataSize" "', argument " "2"" of type '" "bool""'"); } @@ -21851,7 +21423,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -21871,21 +21443,15 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( int res5 = 0 ; int val6 ; int ecode6 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:RTCM2DataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -21893,12 +21459,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RTCM2DataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RTCM2DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21906,7 +21472,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RTCM2DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21914,7 +21480,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } arg5 = reinterpret_cast< Gempa::CAPS::Time * >(argp5); - ecode6 = SWIG_AsVal_int(obj5, &val6); + ecode6 = SWIG_AsVal_int(swig_obj[5], &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RTCM2DataRecord_get" "', argument " "6"" of type '" "int""'"); } @@ -21927,7 +21493,7 @@ fail: } -SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; std::streambuf *arg2 = 0 ; @@ -21944,20 +21510,15 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; Gempa::CAPS::DataRecord::ReadStatus result; - if (!PyArg_ParseTuple(args,(char *)"OOOOO:RTCM2DataRecord_get",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_get" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -21965,12 +21526,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_get" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - 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 '" "RTCM2DataRecord_get" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RTCM2DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21978,7 +21539,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_get" "', argument " "4"" of type '" "Gempa::CAPS::Time const &""'"); } arg4 = reinterpret_cast< Gempa::CAPS::Time * >(argp4); - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RTCM2DataRecord_get" "', argument " "5"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -21999,13 +21560,9 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { PyObject *argv[7] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 6) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_get", 0, 6, argv))) SWIG_fail; + --argc; if (argc == 5) { int _v; void *vptr = 0; @@ -22013,7 +21570,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -22021,13 +21578,13 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RTCM2DataRecord_get__SWIG_1(self, args); + return _wrap_RTCM2DataRecord_get__SWIG_1(self, argc, argv); } } } @@ -22041,7 +21598,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__streambuf, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -22049,10 +21606,10 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, 0); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Gempa__CAPS__Time, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { { @@ -22060,7 +21617,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_RTCM2DataRecord_get__SWIG_0(self, args); + return _wrap_RTCM2DataRecord_get__SWIG_0(self, argc, argv); } } } @@ -22070,7 +21627,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_get(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RTCM2DataRecord_get'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'RTCM2DataRecord_get'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::RTCM2DataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &,int)\n" " Gempa::CAPS::RTCM2DataRecord::get(std::streambuf &,int,Gempa::CAPS::Time const &,Gempa::CAPS::Time const &)\n"); @@ -22089,18 +21646,16 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_put(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; bool val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:RTCM2DataRecord_put",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RTCM2DataRecord_put", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_put" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::RTCM2DataRecord * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTCM2DataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } @@ -22108,7 +21663,7 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_put(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTCM2DataRecord_put" "', argument " "2"" of type '" "std::streambuf &""'"); } arg2 = reinterpret_cast< std::streambuf * >(argp2); - ecode3 = SWIG_AsVal_bool(obj2, &val3); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RTCM2DataRecord_put" "', argument " "3"" of type '" "bool""'"); } @@ -22126,11 +21681,12 @@ SWIGINTERN PyObject *_wrap_RTCM2DataRecord_packetType(PyObject *SWIGUNUSEDPARM(s Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::PacketType result; - if (!PyArg_ParseTuple(args,(char *)"O:RTCM2DataRecord_packetType",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTCM2DataRecord_packetType" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord const *""'"); } @@ -22148,10 +21704,11 @@ SWIGINTERN PyObject *_wrap_delete_RTCM2DataRecord(PyObject *SWIGUNUSEDPARM(self) Gempa::CAPS::RTCM2DataRecord *arg1 = (Gempa::CAPS::RTCM2DataRecord *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_RTCM2DataRecord",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RTCM2DataRecord" "', argument " "1"" of type '" "Gempa::CAPS::RTCM2DataRecord *""'"); } @@ -22166,7 +21723,7 @@ fail: SWIGINTERN PyObject *RTCM2DataRecord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__RTCM2DataRecord, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } @@ -22175,7 +21732,7 @@ SWIGINTERN PyObject *_wrap_new_Socket(PyObject *SWIGUNUSEDPARM(self), PyObject * PyObject *resultobj = 0; Gempa::CAPS::Socket *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_Socket")) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_Socket", 0, 0, 0)) SWIG_fail; result = (Gempa::CAPS::Socket *)new Gempa::CAPS::Socket(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__Socket, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -22189,10 +21746,11 @@ SWIGINTERN PyObject *_wrap_delete_Socket(PyObject *SWIGUNUSEDPARM(self), PyObjec Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_Socket",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Socket" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22210,11 +21768,12 @@ SWIGINTERN PyObject *_wrap_Socket_toString(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::Socket::Status arg1 ; int val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_toString",&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 '" "Socket_toString" "', argument " "1"" of type '" "Gempa::CAPS::Socket::Status""'"); } @@ -22232,11 +21791,12 @@ SWIGINTERN PyObject *_wrap_Socket_fd(PyObject *SWIGUNUSEDPARM(self), PyObject *a Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_fd",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_fd" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22254,11 +21814,12 @@ SWIGINTERN PyObject *_wrap_Socket_isValid(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_isValid",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_isValid" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22276,10 +21837,11 @@ SWIGINTERN PyObject *_wrap_Socket_shutdown(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_shutdown",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_shutdown" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22297,10 +21859,11 @@ SWIGINTERN PyObject *_wrap_Socket_close(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_close",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_close" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22322,17 +21885,16 @@ SWIGINTERN PyObject *_wrap_Socket_send(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:Socket_send",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_send", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_send" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); - 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 '" "Socket_send" "', argument " "2"" of type '" "char const *""'"); } @@ -22359,23 +21921,21 @@ SWIGINTERN PyObject *_wrap_Socket_write(PyObject *SWIGUNUSEDPARM(self), PyObject int alloc2 = 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:Socket_write",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_write", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_write" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); - 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 '" "Socket_write" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "Socket_write" "', argument " "3"" of type '" "int""'"); } @@ -22402,23 +21962,21 @@ SWIGINTERN PyObject *_wrap_Socket_read(PyObject *SWIGUNUSEDPARM(self), PyObject int alloc2 = 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:Socket_read",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_read", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_read" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); - 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 '" "Socket_read" "', argument " "2"" of type '" "char *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "Socket_read" "', argument " "3"" of type '" "int""'"); } @@ -22438,11 +21996,12 @@ SWIGINTERN PyObject *_wrap_Socket_flush(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_flush",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_flush" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } @@ -22466,23 +22025,21 @@ SWIGINTERN PyObject *_wrap_Socket_setSocketTimeout(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; Gempa::CAPS::Socket::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Socket_setSocketTimeout",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_setSocketTimeout", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_setSocketTimeout" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); - 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 '" "Socket_setSocketTimeout" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< 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 '" "Socket_setSocketTimeout" "', argument " "3"" of type '" "int""'"); } @@ -22503,17 +22060,16 @@ SWIGINTERN PyObject *_wrap_Socket_setNonBlocking(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::Socket::Device::Status result; - if (!PyArg_ParseTuple(args,(char *)"OO:Socket_setNonBlocking",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_setNonBlocking", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_setNonBlocking" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); - ecode2 = SWIG_AsVal_bool(obj1, &val2); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Socket_setNonBlocking" "', argument " "2"" of type '" "bool""'"); } @@ -22536,20 +22092,18 @@ SWIGINTERN PyObject *_wrap_Socket_connect(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = SWIG_OLDOBJ ; unsigned short val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; Gempa::CAPS::Socket::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOO:Socket_connect",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Socket_connect", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_connect" "', argument " "1"" of type '" "Gempa::CAPS::Socket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::Socket * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Socket_connect" "', argument " "2"" of type '" "std::string const &""'"); } @@ -22558,7 +22112,7 @@ SWIGINTERN PyObject *_wrap_Socket_connect(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = ptr; } - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Socket_connect" "', argument " "3"" of type '" "uint16_t""'"); } @@ -22578,11 +22132,12 @@ SWIGINTERN PyObject *_wrap_Socket_rx(PyObject *SWIGUNUSEDPARM(self), PyObject *a Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Socket::count_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_rx",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_rx" "', argument " "1"" of type '" "Gempa::CAPS::Socket const *""'"); } @@ -22600,11 +22155,12 @@ SWIGINTERN PyObject *_wrap_Socket_tx(PyObject *SWIGUNUSEDPARM(self), PyObject *a Gempa::CAPS::Socket *arg1 = (Gempa::CAPS::Socket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Socket::count_t result; - if (!PyArg_ParseTuple(args,(char *)"O:Socket_tx",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__Socket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Socket_tx" "', argument " "1"" of type '" "Gempa::CAPS::Socket const *""'"); } @@ -22619,16 +22175,20 @@ fail: SWIGINTERN PyObject *Socket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__Socket, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_SSLSocket__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *Socket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SSLSocket__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; Gempa::CAPS::SSLSocket *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)":new_SSLSocket")) SWIG_fail; + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; result = (Gempa::CAPS::SSLSocket *)new Gempa::CAPS::SSLSocket(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gempa__CAPS__SSLSocket, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -22637,16 +22197,15 @@ fail: } -SWIGINTERN PyObject *_wrap_new_SSLSocket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_SSLSocket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; SSL_CTX *arg1 = (SSL_CTX *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; Gempa::CAPS::SSLSocket *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_SSLSocket",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SSL_CTX, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SSL_CTX, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SSLSocket" "', argument " "1"" of type '" "SSL_CTX *""'"); } @@ -22664,15 +22223,11 @@ SWIGINTERN PyObject *_wrap_new_SSLSocket(PyObject *self, PyObject *args) { PyObject *argv[2] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SSLSocket", 0, 1, argv))) SWIG_fail; + --argc; if (argc == 0) { - return _wrap_new_SSLSocket__SWIG_0(self, args); + return _wrap_new_SSLSocket__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -22680,12 +22235,12 @@ SWIGINTERN PyObject *_wrap_new_SSLSocket(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_SSL_CTX, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SSLSocket__SWIG_1(self, args); + return _wrap_new_SSLSocket__SWIG_1(self, argc, argv); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SSLSocket'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SSLSocket'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::SSLSocket::SSLSocket()\n" " Gempa::CAPS::SSLSocket::SSLSocket(SSL_CTX *)\n"); @@ -22698,10 +22253,11 @@ SWIGINTERN PyObject *_wrap_delete_SSLSocket(PyObject *SWIGUNUSEDPARM(self), PyOb Gempa::CAPS::SSLSocket *arg1 = (Gempa::CAPS::SSLSocket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_SSLSocket",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SSLSocket" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket *""'"); } @@ -22726,23 +22282,21 @@ SWIGINTERN PyObject *_wrap_SSLSocket_write(PyObject *SWIGUNUSEDPARM(self), PyObj int alloc2 = 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:SSLSocket_write",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SSLSocket_write", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_write" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SSLSocket * >(argp1); - 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 '" "SSLSocket_write" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "SSLSocket_write" "', argument " "3"" of type '" "int""'"); } @@ -22769,23 +22323,21 @@ SWIGINTERN PyObject *_wrap_SSLSocket_read(PyObject *SWIGUNUSEDPARM(self), PyObje int alloc2 = 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:SSLSocket_read",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SSLSocket_read", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_read" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SSLSocket * >(argp1); - 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 '" "SSLSocket_read" "', argument " "2"" of type '" "char *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "SSLSocket_read" "', argument " "3"" of type '" "int""'"); } @@ -22810,20 +22362,18 @@ SWIGINTERN PyObject *_wrap_SSLSocket_connect(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = SWIG_OLDOBJ ; unsigned short val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; Gempa::CAPS::Socket::Status result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SSLSocket_connect",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SSLSocket_connect", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_connect" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::SSLSocket * >(argp1); { std::string *ptr = (std::string *)0; - res2 = SWIG_AsPtr_std_string(obj1, &ptr); + res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SSLSocket_connect" "', argument " "2"" of type '" "std::string const &""'"); } @@ -22832,7 +22382,7 @@ SWIGINTERN PyObject *_wrap_SSLSocket_connect(PyObject *SWIGUNUSEDPARM(self), PyO } arg2 = ptr; } - ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3); + ecode3 = SWIG_AsVal_unsigned_SS_short(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SSLSocket_connect" "', argument " "3"" of type '" "uint16_t""'"); } @@ -22852,11 +22402,12 @@ SWIGINTERN PyObject *_wrap_SSLSocket_sessionID(PyObject *SWIGUNUSEDPARM(self), P Gempa::CAPS::SSLSocket *arg1 = (Gempa::CAPS::SSLSocket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; unsigned char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SSLSocket_sessionID",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_sessionID" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket const *""'"); } @@ -22874,11 +22425,12 @@ SWIGINTERN PyObject *_wrap_SSLSocket_sessionIDLength(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::SSLSocket *arg1 = (Gempa::CAPS::SSLSocket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; unsigned int result; - if (!PyArg_ParseTuple(args,(char *)"O:SSLSocket_sessionIDLength",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_sessionIDLength" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket const *""'"); } @@ -22896,11 +22448,12 @@ SWIGINTERN PyObject *_wrap_SSLSocket_peerCertificate(PyObject *SWIGUNUSEDPARM(se Gempa::CAPS::SSLSocket *arg1 = (Gempa::CAPS::SSLSocket *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; X509 *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:SSLSocket_peerCertificate",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__SSLSocket, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SSLSocket_peerCertificate" "', argument " "1"" of type '" "Gempa::CAPS::SSLSocket *""'"); } @@ -22915,21 +22468,26 @@ fail: SWIGINTERN PyObject *SSLSocket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__SSLSocket, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *SSLSocket_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_charArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; size_t arg1 ; size_t val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; charArray *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_charArray",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_size_t(obj0, &val1); + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_charArray" "', argument " "1"" of type '" "size_t""'"); } @@ -22947,10 +22505,11 @@ SWIGINTERN PyObject *_wrap_delete_charArray(PyObject *SWIGUNUSEDPARM(self), PyOb charArray *arg1 = (charArray *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_charArray",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_charArray, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charArray, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_charArray" "', argument " "1"" of type '" "charArray *""'"); } @@ -22971,17 +22530,16 @@ SWIGINTERN PyObject *_wrap_charArray___getitem__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; size_t val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; char result; - if (!PyArg_ParseTuple(args,(char *)"OO:charArray___getitem__",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_charArray, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "charArray___getitem__", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charArray___getitem__" "', argument " "1"" of type '" "charArray *""'"); } arg1 = reinterpret_cast< charArray * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "charArray___getitem__" "', argument " "2"" of type '" "size_t""'"); } @@ -23005,22 +22563,20 @@ SWIGINTERN PyObject *_wrap_charArray___setitem__(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; char val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; - if (!PyArg_ParseTuple(args,(char *)"OOO:charArray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_charArray, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "charArray___setitem__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charArray___setitem__" "', argument " "1"" of type '" "charArray *""'"); } arg1 = reinterpret_cast< charArray * >(argp1); - ecode2 = SWIG_AsVal_size_t(obj1, &val2); + ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "charArray___setitem__" "', argument " "2"" of type '" "size_t""'"); } arg2 = static_cast< size_t >(val2); - ecode3 = SWIG_AsVal_char(obj2, &val3); + ecode3 = SWIG_AsVal_char(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "charArray___setitem__" "', argument " "3"" of type '" "char""'"); } @@ -23038,11 +22594,12 @@ SWIGINTERN PyObject *_wrap_charArray_cast(PyObject *SWIGUNUSEDPARM(self), PyObje charArray *arg1 = (charArray *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:charArray_cast",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_charArray, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_charArray, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "charArray_cast" "', argument " "1"" of type '" "charArray *""'"); } @@ -23061,11 +22618,12 @@ SWIGINTERN PyObject *_wrap_charArray_frompointer(PyObject *SWIGUNUSEDPARM(self), int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; charArray *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:charArray_frompointer",&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 '" "charArray_frompointer" "', argument " "1"" of type '" "char *""'"); } @@ -23082,12 +22640,16 @@ fail: SWIGINTERN PyObject *charArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_charArray, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_arraybuf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *charArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_arraybuf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int arg2 ; @@ -23096,17 +22658,15 @@ SWIGINTERN PyObject *_wrap_new_arraybuf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int alloc1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; Gempa::CAPS::arraybuf *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:new_arraybuf",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arraybuf" "', argument " "1"" of type '" "char const *""'"); } arg1 = reinterpret_cast< 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 '" "new_arraybuf" "', argument " "2"" of type '" "int""'"); } @@ -23121,17 +22681,16 @@ fail: } -SWIGINTERN PyObject *_wrap_new_arraybuf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_arraybuf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; Gempa::CAPS::arraybuf *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:new_arraybuf",&obj0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_arraybuf" "', argument " "1"" of type '" "std::string const &""'"); } @@ -23155,19 +22714,15 @@ SWIGINTERN PyObject *_wrap_new_arraybuf(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "new_arraybuf", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_arraybuf__SWIG_1(self, args); + return _wrap_new_arraybuf__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -23180,13 +22735,13 @@ SWIGINTERN PyObject *_wrap_new_arraybuf(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_arraybuf__SWIG_0(self, args); + return _wrap_new_arraybuf__SWIG_0(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_arraybuf'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_arraybuf'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::arraybuf::arraybuf(char const *,int)\n" " Gempa::CAPS::arraybuf::arraybuf(std::string const &)\n"); @@ -23206,22 +22761,20 @@ SWIGINTERN PyObject *_wrap_arraybuf_reset(PyObject *SWIGUNUSEDPARM(self), PyObje int alloc2 = 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:arraybuf_reset",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "arraybuf_reset", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_reset" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::arraybuf * >(argp1); - 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 '" "arraybuf_reset" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "arraybuf_reset" "', argument " "3"" of type '" "int""'"); } @@ -23250,20 +22803,17 @@ SWIGINTERN PyObject *_wrap_arraybuf_seekoff(PyObject *SWIGUNUSEDPARM(self), PyOb int res3 = 0 ; void *argp4 ; int res4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; + PyObject *swig_obj[4] ; Gempa::CAPS::arraybuf::pos_type result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:arraybuf_seekoff",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "arraybuf_seekoff", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_seekoff" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::arraybuf * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf__off_type, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf__off_type, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arraybuf_seekoff" "', argument " "2"" of type '" "Gempa::CAPS::arraybuf::off_type""'"); } @@ -23276,7 +22826,7 @@ SWIGINTERN PyObject *_wrap_arraybuf_seekoff(PyObject *SWIGUNUSEDPARM(self), PyOb } } { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__ios_base__seekdir, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__ios_base__seekdir, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arraybuf_seekoff" "', argument " "3"" of type '" "std::ios_base::seekdir""'"); } @@ -23289,7 +22839,7 @@ SWIGINTERN PyObject *_wrap_arraybuf_seekoff(PyObject *SWIGUNUSEDPARM(self), PyOb } } { - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__ios_base__openmode, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__ios_base__openmode, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "arraybuf_seekoff" "', argument " "4"" of type '" "std::ios_base::openmode""'"); } @@ -23320,19 +22870,17 @@ SWIGINTERN PyObject *_wrap_arraybuf_seekpos(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; Gempa::CAPS::arraybuf::pos_type result; - if (!PyArg_ParseTuple(args,(char *)"OOO:arraybuf_seekpos",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "arraybuf_seekpos", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_seekpos" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::arraybuf * >(argp1); { - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__streambuf__pos_type, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__streambuf__pos_type, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "arraybuf_seekpos" "', argument " "2"" of type '" "Gempa::CAPS::arraybuf::pos_type""'"); } @@ -23345,7 +22893,7 @@ SWIGINTERN PyObject *_wrap_arraybuf_seekpos(PyObject *SWIGUNUSEDPARM(self), PyOb } } { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__ios_base__openmode, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__ios_base__openmode, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arraybuf_seekpos" "', argument " "3"" of type '" "std::ios_base::openmode""'"); } @@ -23377,24 +22925,22 @@ SWIGINTERN PyObject *_wrap_arraybuf_xsgetn(PyObject *SWIGUNUSEDPARM(self), PyObj int alloc2 = 0 ; void *argp3 ; int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + PyObject *swig_obj[3] ; std::streamsize result; - if (!PyArg_ParseTuple(args,(char *)"OOO:arraybuf_xsgetn",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "arraybuf_xsgetn", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_xsgetn" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } arg1 = reinterpret_cast< Gempa::CAPS::arraybuf * >(argp1); - 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 '" "arraybuf_xsgetn" "', argument " "2"" of type '" "char *""'"); } arg2 = reinterpret_cast< char * >(buf2); { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__streamsize, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__streamsize, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "arraybuf_xsgetn" "', argument " "3"" of type '" "std::streamsize""'"); } @@ -23421,11 +22967,12 @@ SWIGINTERN PyObject *_wrap_arraybuf_tellg(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::arraybuf *arg1 = (Gempa::CAPS::arraybuf *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::streampos result; - if (!PyArg_ParseTuple(args,(char *)"O:arraybuf_tellg",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_tellg" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } @@ -23443,11 +22990,12 @@ SWIGINTERN PyObject *_wrap_arraybuf_tellp(PyObject *SWIGUNUSEDPARM(self), PyObje Gempa::CAPS::arraybuf *arg1 = (Gempa::CAPS::arraybuf *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; std::streampos result; - if (!PyArg_ParseTuple(args,(char *)"O:arraybuf_tellp",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arraybuf_tellp" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } @@ -23465,10 +23013,11 @@ SWIGINTERN PyObject *_wrap_delete_arraybuf(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::arraybuf *arg1 = (Gempa::CAPS::arraybuf *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; - if (!PyArg_ParseTuple(args,(char *)"O:delete_arraybuf",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, SWIG_POINTER_DISOWN | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_Gempa__CAPS__arraybuf, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_arraybuf" "', argument " "1"" of type '" "Gempa::CAPS::arraybuf *""'"); } @@ -23483,11 +23032,15 @@ fail: SWIGINTERN PyObject *arraybuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; - if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; SWIG_TypeNewClientData(SWIGTYPE_p_Gempa__CAPS__arraybuf, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } +SWIGINTERN PyObject *arraybuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_splitAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; std::string *arg1 = 0 ; @@ -23501,14 +23054,11 @@ SWIGINTERN PyObject *_wrap_splitAddress(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = SWIG_OLDOBJ ; unsigned short val4 ; int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; + PyObject *swig_obj[4] ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:splitAddress",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 ); + if (!SWIG_Python_UnpackTuple(args, "splitAddress", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "splitAddress" "', argument " "1"" of type '" "std::string &""'"); } @@ -23516,7 +23066,7 @@ SWIGINTERN PyObject *_wrap_splitAddress(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "splitAddress" "', argument " "1"" of type '" "std::string &""'"); } arg1 = reinterpret_cast< std::string * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_short, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_unsigned_short, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "splitAddress" "', argument " "2"" of type '" "unsigned short &""'"); } @@ -23526,7 +23076,7 @@ SWIGINTERN PyObject *_wrap_splitAddress(PyObject *SWIGUNUSEDPARM(self), PyObject arg2 = reinterpret_cast< unsigned short * >(argp2); { std::string *ptr = (std::string *)0; - res3 = SWIG_AsPtr_std_string(obj2, &ptr); + res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "splitAddress" "', argument " "3"" of type '" "std::string const &""'"); } @@ -23535,7 +23085,7 @@ SWIGINTERN PyObject *_wrap_splitAddress(PyObject *SWIGUNUSEDPARM(self), PyObject } arg3 = ptr; } - ecode4 = SWIG_AsVal_unsigned_SS_short(obj3, &val4); + ecode4 = SWIG_AsVal_unsigned_SS_short(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "splitAddress" "', argument " "4"" of type '" "unsigned short""'"); } @@ -23566,24 +23116,21 @@ SWIGINTERN PyObject *_wrap_tokenize(PyObject *SWIGUNUSEDPARM(self), PyObject *ar 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] ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OOOO:tokenize",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_Python_UnpackTuple(args, "tokenize", 4, 4, 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 '" "tokenize" "', argument " "1"" of type '" "char const *&""'"); } arg1 = &buf1; - 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 '" "tokenize" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tokenize" "', argument " "3"" of type '" "int &""'"); } @@ -23591,7 +23138,7 @@ SWIGINTERN PyObject *_wrap_tokenize(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tokenize" "', argument " "3"" of type '" "int &""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tokenize" "', argument " "4"" of type '" "int &""'"); } @@ -23611,7 +23158,7 @@ fail: } -SWIGINTERN PyObject *_wrap_trim__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_trim__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char **arg1 = 0 ; int *arg2 = 0 ; @@ -23620,17 +23167,15 @@ SWIGINTERN PyObject *_wrap_trim__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject int alloc1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; char *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"OO:trim",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trim" "', argument " "1"" of type '" "char const *&""'"); } arg1 = &buf1; - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trim" "', argument " "2"" of type '" "int &""'"); } @@ -23648,17 +23193,16 @@ fail: } -SWIGINTERN PyObject *_wrap_trim__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_trim__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int res1 = SWIG_OLDOBJ ; - PyObject * obj0 = 0 ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"O:trim",&obj0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { std::string *ptr = (std::string *)0; - res1 = SWIG_AsPtr_std_string(obj0, &ptr); + res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trim" "', argument " "1"" of type '" "std::string const &""'"); } @@ -23682,19 +23226,15 @@ SWIGINTERN PyObject *_wrap_trim(PyObject *self, PyObject *args) { PyObject *argv[3] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "trim", 0, 2, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_trim__SWIG_1(self, args); + return _wrap_trim__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -23703,16 +23243,16 @@ SWIGINTERN PyObject *_wrap_trim(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_trim__SWIG_0(self, args); + return _wrap_trim__SWIG_0(self, argc, argv); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'trim'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'trim'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::trim(char const *&,int &)\n" " Gempa::CAPS::trim(std::string const &)\n"); @@ -23728,11 +23268,10 @@ SWIGINTERN PyObject *_wrap_timeToTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; - if (!PyArg_ParseTuple(args,(char *)"OO:timeToTimestamp",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 ); + if (!SWIG_Python_UnpackTuple(args, "timeToTimestamp", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "timeToTimestamp" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp &""'"); } @@ -23740,7 +23279,7 @@ SWIGINTERN PyObject *_wrap_timeToTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "timeToTimestamp" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp &""'"); } arg1 = reinterpret_cast< Gempa::CAPS::TimeStamp * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__Time, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "timeToTimestamp" "', argument " "2"" of type '" "Gempa::CAPS::Time const &""'"); } @@ -23756,7 +23295,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -23771,14 +23310,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:str2int",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } @@ -23786,17 +23321,17 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "str2int" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "str2int" "', argument " "4"" of type '" "int""'"); } @@ -23811,7 +23346,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -23823,13 +23358,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObj int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:str2int",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } @@ -23837,12 +23369,12 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "str2int" "', argument " "3"" of type '" "int""'"); } @@ -23857,7 +23389,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -23866,12 +23398,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:str2int",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } @@ -23879,7 +23409,7 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } @@ -23894,7 +23424,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; uint16_t *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -23909,14 +23439,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:str2int",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_unsigned_short, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_unsigned_short, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } @@ -23924,17 +23450,17 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } arg1 = reinterpret_cast< uint16_t * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "str2int" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< 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 '" "str2int" "', argument " "4"" of type '" "int""'"); } @@ -23949,7 +23475,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; uint16_t *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -23961,13 +23487,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObj int alloc2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OOO:str2int",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_unsigned_short, 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_unsigned_short, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } @@ -23975,12 +23498,12 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } arg1 = reinterpret_cast< uint16_t * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - 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 '" "str2int" "', argument " "3"" of type '" "int""'"); } @@ -23995,7 +23518,7 @@ fail: } -SWIGINTERN PyObject *_wrap_str2int__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_str2int__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; uint16_t *arg1 = 0 ; char *arg2 = (char *) 0 ; @@ -24004,12 +23527,10 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; bool result; - if (!PyArg_ParseTuple(args,(char *)"OO:str2int",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_unsigned_short, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_unsigned_short, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } @@ -24017,7 +23538,7 @@ SWIGINTERN PyObject *_wrap_str2int__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "str2int" "', argument " "1"" of type '" "uint16_t &""'"); } arg1 = reinterpret_cast< uint16_t * >(argp1); - 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 '" "str2int" "', argument " "2"" of type '" "char const *""'"); } @@ -24037,43 +23558,39 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { PyObject *argv[5] = { 0 }; - Py_ssize_t ii; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 4) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "str2int", 0, 4, argv))) SWIG_fail; + --argc; if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_str2int__SWIG_5(self, args); + return _wrap_str2int__SWIG_5(self, argc, argv); } } } if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_str2int__SWIG_8(self, args); + return _wrap_str2int__SWIG_8(self, argc, argv); } } } if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); @@ -24084,7 +23601,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_str2int__SWIG_7(self, args); + return _wrap_str2int__SWIG_7(self, argc, argv); } } } @@ -24092,7 +23609,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); @@ -24103,7 +23620,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_str2int__SWIG_4(self, args); + return _wrap_str2int__SWIG_4(self, argc, argv); } } } @@ -24111,7 +23628,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); @@ -24127,7 +23644,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_str2int__SWIG_3(self, args); + return _wrap_str2int__SWIG_3(self, argc, argv); } } } @@ -24136,7 +23653,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); @@ -24152,7 +23669,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_str2int__SWIG_6(self, args); + return _wrap_str2int__SWIG_6(self, argc, argv); } } } @@ -24160,7 +23677,7 @@ SWIGINTERN PyObject *_wrap_str2int(PyObject *self, PyObject *args) { } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'str2int'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str2int'.\n" " Possible C/C++ prototypes are:\n" " Gempa::CAPS::str2int(int &,char const *,int,int)\n" " Gempa::CAPS::str2int(int &,char const *,int)\n" @@ -24177,11 +23694,12 @@ SWIGINTERN PyObject *_wrap_timestampToTime(PyObject *SWIGUNUSEDPARM(self), PyObj Gempa::CAPS::TimeStamp *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; Gempa::CAPS::Time result; - if (!PyArg_ParseTuple(args,(char *)"O:timestampToTime",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__TimeStamp, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "timestampToTime" "', argument " "1"" of type '" "Gempa::CAPS::TimeStamp const &""'"); } @@ -24205,12 +23723,11 @@ SWIGINTERN PyObject *_wrap_samplesToTimeSpan(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; Gempa::CAPS::TimeSpan result; - if (!PyArg_ParseTuple(args,(char *)"OO:samplesToTimeSpan",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "samplesToTimeSpan", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "samplesToTimeSpan" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } @@ -24218,7 +23735,7 @@ SWIGINTERN PyObject *_wrap_samplesToTimeSpan(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "samplesToTimeSpan" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp1); - 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 '" "samplesToTimeSpan" "', argument " "2"" of type '" "int""'"); } @@ -24239,12 +23756,11 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamples(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; int result; - if (!PyArg_ParseTuple(args,(char *)"OO:timeSpanToSamples",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "timeSpanToSamples", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "timeSpanToSamples" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } @@ -24252,7 +23768,7 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamples(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "timeSpanToSamples" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "timeSpanToSamples" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -24276,12 +23792,11 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamplesCeil(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; int result; - if (!PyArg_ParseTuple(args,(char *)"OO:timeSpanToSamplesCeil",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "timeSpanToSamplesCeil", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "timeSpanToSamplesCeil" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } @@ -24289,7 +23804,7 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamplesCeil(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "timeSpanToSamplesCeil" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "timeSpanToSamplesCeil" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -24313,12 +23828,11 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamplesFloor(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + PyObject *swig_obj[2] ; int result; - if (!PyArg_ParseTuple(args,(char *)"OO:timeSpanToSamplesFloor",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "timeSpanToSamplesFloor", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Gempa__CAPS__DataRecord__Header, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "timeSpanToSamplesFloor" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } @@ -24326,7 +23840,7 @@ SWIGINTERN PyObject *_wrap_timeSpanToSamplesFloor(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "timeSpanToSamplesFloor" "', argument " "1"" of type '" "Gempa::CAPS::DataRecord::Header const &""'"); } arg1 = reinterpret_cast< Gempa::CAPS::DataRecord::Header * >(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_Gempa__CAPS__TimeSpan, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "timeSpanToSamplesFloor" "', argument " "2"" of type '" "Gempa::CAPS::TimeSpan const &""'"); } @@ -24347,11 +23861,12 @@ SWIGINTERN PyObject *_wrap_dataTypeSize(PyObject *SWIGUNUSEDPARM(self), PyObject Gempa::CAPS::DataType arg1 ; int val1 ; int ecode1 = 0 ; - PyObject * obj0 = 0 ; + PyObject *swig_obj[1] ; uint8_t result; - if (!PyArg_ParseTuple(args,(char *)"O:dataTypeSize",&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 '" "dataTypeSize" "', argument " "1"" of type '" "Gempa::CAPS::DataType""'"); } @@ -24365,484 +23880,522 @@ fail: static PyMethodDef SwigMethods[] = { - { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL}, - { (char *)"new_TimeSpan", _wrap_new_TimeSpan, METH_VARARGS, NULL}, - { (char *)"TimeSpan___eq__", _wrap_TimeSpan___eq__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___ne__", _wrap_TimeSpan___ne__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___lt__", _wrap_TimeSpan___lt__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___le__", _wrap_TimeSpan___le__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___gt__", _wrap_TimeSpan___gt__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___ge__", _wrap_TimeSpan___ge__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___add__", _wrap_TimeSpan___add__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___sub__", _wrap_TimeSpan___sub__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___iadd__", _wrap_TimeSpan___iadd__, METH_VARARGS, NULL}, - { (char *)"TimeSpan___isub__", _wrap_TimeSpan___isub__, METH_VARARGS, NULL}, - { (char *)"TimeSpan_abs", _wrap_TimeSpan_abs, METH_VARARGS, NULL}, - { (char *)"TimeSpan_seconds", _wrap_TimeSpan_seconds, METH_VARARGS, NULL}, - { (char *)"TimeSpan_microseconds", _wrap_TimeSpan_microseconds, METH_VARARGS, NULL}, - { (char *)"TimeSpan_length", _wrap_TimeSpan_length, METH_VARARGS, NULL}, - { (char *)"TimeSpan_set", _wrap_TimeSpan_set, METH_VARARGS, NULL}, - { (char *)"TimeSpan_setUSecs", _wrap_TimeSpan_setUSecs, METH_VARARGS, NULL}, - { (char *)"TimeSpan_elapsedTime", _wrap_TimeSpan_elapsedTime, METH_VARARGS, NULL}, - { (char *)"delete_TimeSpan", _wrap_delete_TimeSpan, METH_VARARGS, NULL}, - { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL}, - { (char *)"new_Time", _wrap_new_Time, METH_VARARGS, NULL}, - { (char *)"Time___nonzero__", _wrap_Time___nonzero__, METH_VARARGS, NULL}, - { (char *)"Time___add__", _wrap_Time___add__, METH_VARARGS, NULL}, - { (char *)"Time___sub__", _wrap_Time___sub__, METH_VARARGS, NULL}, - { (char *)"Time___iadd__", _wrap_Time___iadd__, METH_VARARGS, NULL}, - { (char *)"Time___isub__", _wrap_Time___isub__, METH_VARARGS, NULL}, - { (char *)"Time_set", _wrap_Time_set, METH_VARARGS, NULL}, - { (char *)"Time_get", _wrap_Time_get, METH_VARARGS, NULL}, - { (char *)"Time_get2", _wrap_Time_get2, METH_VARARGS, NULL}, - { (char *)"Time_LocalTime", _wrap_Time_LocalTime, METH_VARARGS, NULL}, - { (char *)"Time_GMT", _wrap_Time_GMT, METH_VARARGS, NULL}, - { (char *)"Time_FromYearDay", _wrap_Time_FromYearDay, METH_VARARGS, NULL}, - { (char *)"Time_localtime", _wrap_Time_localtime, METH_VARARGS, NULL}, - { (char *)"Time_gmt", _wrap_Time_gmt, METH_VARARGS, NULL}, - { (char *)"Time_toLocalTime", _wrap_Time_toLocalTime, METH_VARARGS, NULL}, - { (char *)"Time_toGMT", _wrap_Time_toGMT, METH_VARARGS, NULL}, - { (char *)"Time_valid", _wrap_Time_valid, METH_VARARGS, NULL}, - { (char *)"Time_toString", _wrap_Time_toString, METH_VARARGS, NULL}, - { (char *)"Time_iso", _wrap_Time_iso, METH_VARARGS, NULL}, - { (char *)"Time_fromString", _wrap_Time_fromString, METH_VARARGS, NULL}, - { (char *)"Time_FromString", _wrap_Time_FromString, METH_VARARGS, NULL}, - { (char *)"delete_Time", _wrap_delete_Time, METH_VARARGS, NULL}, - { (char *)"Time_swigregister", Time_swigregister, METH_VARARGS, NULL}, - { (char *)"UOM_str_set", _wrap_UOM_str_set, METH_VARARGS, NULL}, - { (char *)"UOM_str_get", _wrap_UOM_str_get, METH_VARARGS, NULL}, - { (char *)"UOM_ID_set", _wrap_UOM_ID_set, METH_VARARGS, NULL}, - { (char *)"UOM_ID_get", _wrap_UOM_ID_get, METH_VARARGS, NULL}, - { (char *)"new_UOM", _wrap_new_UOM, METH_VARARGS, NULL}, - { (char *)"delete_UOM", _wrap_delete_UOM, METH_VARARGS, NULL}, - { (char *)"UOM_swigregister", UOM_swigregister, METH_VARARGS, NULL}, - { (char *)"Quality_str_set", _wrap_Quality_str_set, METH_VARARGS, NULL}, - { (char *)"Quality_str_get", _wrap_Quality_str_get, METH_VARARGS, NULL}, - { (char *)"Quality_ID_set", _wrap_Quality_ID_set, METH_VARARGS, NULL}, - { (char *)"Quality_ID_get", _wrap_Quality_ID_get, METH_VARARGS, NULL}, - { (char *)"new_Quality", _wrap_new_Quality, METH_VARARGS, NULL}, - { (char *)"delete_Quality", _wrap_delete_Quality, METH_VARARGS, NULL}, - { (char *)"Quality_swigregister", Quality_swigregister, METH_VARARGS, NULL}, - { (char *)"TimeStamp_year_set", _wrap_TimeStamp_year_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_year_get", _wrap_TimeStamp_year_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_yday_set", _wrap_TimeStamp_yday_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_yday_get", _wrap_TimeStamp_yday_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_hour_set", _wrap_TimeStamp_hour_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_hour_get", _wrap_TimeStamp_hour_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_minute_set", _wrap_TimeStamp_minute_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_minute_get", _wrap_TimeStamp_minute_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_second_set", _wrap_TimeStamp_second_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_second_get", _wrap_TimeStamp_second_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_unused_set", _wrap_TimeStamp_unused_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_unused_get", _wrap_TimeStamp_unused_get, METH_VARARGS, NULL}, - { (char *)"TimeStamp_usec_set", _wrap_TimeStamp_usec_set, METH_VARARGS, NULL}, - { (char *)"TimeStamp_usec_get", _wrap_TimeStamp_usec_get, METH_VARARGS, NULL}, - { (char *)"new_TimeStamp", _wrap_new_TimeStamp, METH_VARARGS, NULL}, - { (char *)"delete_TimeStamp", _wrap_delete_TimeStamp, METH_VARARGS, NULL}, - { (char *)"TimeStamp_swigregister", TimeStamp_swigregister, METH_VARARGS, NULL}, - { (char *)"new_PacketDataHeader", _wrap_new_PacketDataHeader, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_version_set", _wrap_PacketDataHeader_version_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_version_get", _wrap_PacketDataHeader_version_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_packetType_set", _wrap_PacketDataHeader_packetType_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_packetType_get", _wrap_PacketDataHeader_packetType_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_unitOfMeasurement_set", _wrap_PacketDataHeader_unitOfMeasurement_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_unitOfMeasurement_get", _wrap_PacketDataHeader_unitOfMeasurement_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_setUOM", _wrap_PacketDataHeader_setUOM, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_uom", _wrap_PacketDataHeader_uom, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader___ne__", _wrap_PacketDataHeader___ne__, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_dataSize", _wrap_PacketDataHeader_dataSize, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_put", _wrap_PacketDataHeader_put, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_get", _wrap_PacketDataHeader_get, METH_VARARGS, NULL}, - { (char *)"delete_PacketDataHeader", _wrap_delete_PacketDataHeader, METH_VARARGS, NULL}, - { (char *)"PacketDataHeader_swigregister", PacketDataHeader_swigregister, METH_VARARGS, NULL}, - { (char *)"new_PacketDataHeaderV2", _wrap_new_PacketDataHeaderV2, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_samplingFrequencyNumerator_set", _wrap_PacketDataHeaderV2_samplingFrequencyNumerator_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_samplingFrequencyNumerator_get", _wrap_PacketDataHeaderV2_samplingFrequencyNumerator_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_samplingFrequencyDenominator_set", _wrap_PacketDataHeaderV2_samplingFrequencyDenominator_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_samplingFrequencyDenominator_get", _wrap_PacketDataHeaderV2_samplingFrequencyDenominator_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_quality_set", _wrap_PacketDataHeaderV2_quality_set, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_quality_get", _wrap_PacketDataHeaderV2_quality_get, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2___ne__", _wrap_PacketDataHeaderV2___ne__, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_dataSize", _wrap_PacketDataHeaderV2_dataSize, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_put", _wrap_PacketDataHeaderV2_put, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_get", _wrap_PacketDataHeaderV2_get, METH_VARARGS, NULL}, - { (char *)"delete_PacketDataHeaderV2", _wrap_delete_PacketDataHeaderV2, METH_VARARGS, NULL}, - { (char *)"PacketDataHeaderV2_swigregister", PacketDataHeaderV2_swigregister, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_SIDSize_set", _wrap_PacketHeaderV1_SIDSize_set, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_SIDSize_get", _wrap_PacketHeaderV1_SIDSize_get, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_size_set", _wrap_PacketHeaderV1_size_set, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_size_get", _wrap_PacketHeaderV1_size_get, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_put", _wrap_PacketHeaderV1_put, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_dataSize", _wrap_PacketHeaderV1_dataSize, METH_VARARGS, NULL}, - { (char *)"new_PacketHeaderV1", _wrap_new_PacketHeaderV1, METH_VARARGS, NULL}, - { (char *)"delete_PacketHeaderV1", _wrap_delete_PacketHeaderV1, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV1_swigregister", PacketHeaderV1_swigregister, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_SIDSize_set", _wrap_PacketHeaderV2_SIDSize_set, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_SIDSize_get", _wrap_PacketHeaderV2_SIDSize_get, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_size_set", _wrap_PacketHeaderV2_size_set, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_size_get", _wrap_PacketHeaderV2_size_get, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_put", _wrap_PacketHeaderV2_put, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_dataSize", _wrap_PacketHeaderV2_dataSize, METH_VARARGS, NULL}, - { (char *)"new_PacketHeaderV2", _wrap_new_PacketHeaderV2, METH_VARARGS, NULL}, - { (char *)"delete_PacketHeaderV2", _wrap_delete_PacketHeaderV2, METH_VARARGS, NULL}, - { (char *)"PacketHeaderV2_swigregister", PacketHeaderV2_swigregister, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_id_set", _wrap_ResponseHeader_id_set, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_id_get", _wrap_ResponseHeader_id_get, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_size_set", _wrap_ResponseHeader_size_set, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_size_get", _wrap_ResponseHeader_size_get, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_get", _wrap_ResponseHeader_get, METH_VARARGS, NULL}, - { (char *)"new_ResponseHeader", _wrap_new_ResponseHeader, METH_VARARGS, NULL}, - { (char *)"delete_ResponseHeader", _wrap_delete_ResponseHeader, METH_VARARGS, NULL}, - { (char *)"ResponseHeader_swigregister", ResponseHeader_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_DataRecord", _wrap_delete_DataRecord, METH_VARARGS, NULL}, - { (char *)"DataRecord_formatName", _wrap_DataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"DataRecord_readMetaData", _wrap_DataRecord_readMetaData, METH_VARARGS, NULL}, - { (char *)"DataRecord_canTrim", _wrap_DataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"DataRecord_canMerge", _wrap_DataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"DataRecord_trim", _wrap_DataRecord_trim, METH_VARARGS, NULL}, - { (char *)"DataRecord_dataSize", _wrap_DataRecord_dataSize, METH_VARARGS, NULL}, - { (char *)"DataRecord_get", _wrap_DataRecord_get, METH_VARARGS, NULL}, - { (char *)"DataRecord_put", _wrap_DataRecord_put, METH_VARARGS, NULL}, - { (char *)"DataRecord_header", _wrap_DataRecord_header, METH_VARARGS, NULL}, - { (char *)"DataRecord_startTime", _wrap_DataRecord_startTime, METH_VARARGS, NULL}, - { (char *)"DataRecord_endTime", _wrap_DataRecord_endTime, METH_VARARGS, NULL}, - { (char *)"DataRecord_packetType", _wrap_DataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"DataRecord_buffer", _wrap_DataRecord_buffer, METH_VARARGS, NULL}, - { (char *)"DataRecord_data", _wrap_DataRecord_data, METH_VARARGS, NULL}, - { (char *)"DataRecord_swigregister", DataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"RawPacket_header_set", _wrap_RawPacket_header_set, METH_VARARGS, NULL}, - { (char *)"RawPacket_header_get", _wrap_RawPacket_header_get, METH_VARARGS, NULL}, - { (char *)"RawPacket_SID_set", _wrap_RawPacket_SID_set, METH_VARARGS, NULL}, - { (char *)"RawPacket_SID_get", _wrap_RawPacket_SID_get, METH_VARARGS, NULL}, - { (char *)"RawPacket_data_set", _wrap_RawPacket_data_set, METH_VARARGS, NULL}, - { (char *)"RawPacket_data_get", _wrap_RawPacket_data_get, METH_VARARGS, NULL}, - { (char *)"RawPacket_record_set", _wrap_RawPacket_record_set, METH_VARARGS, NULL}, - { (char *)"RawPacket_record_get", _wrap_RawPacket_record_get, METH_VARARGS, NULL}, - { (char *)"new_RawPacket", _wrap_new_RawPacket, METH_VARARGS, NULL}, - { (char *)"delete_RawPacket", _wrap_delete_RawPacket, METH_VARARGS, NULL}, - { (char *)"RawPacket_swigregister", RawPacket_swigregister, METH_VARARGS, NULL}, - { (char *)"MetaPacket_SID_set", _wrap_MetaPacket_SID_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_SID_get", _wrap_MetaPacket_SID_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_packetDataHeader_set", _wrap_MetaPacket_packetDataHeader_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_packetDataHeader_get", _wrap_MetaPacket_packetDataHeader_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_record_set", _wrap_MetaPacket_record_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_record_get", _wrap_MetaPacket_record_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_recordHeader_set", _wrap_MetaPacket_recordHeader_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_recordHeader_get", _wrap_MetaPacket_recordHeader_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_startTime_set", _wrap_MetaPacket_startTime_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_startTime_get", _wrap_MetaPacket_startTime_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_endTime_set", _wrap_MetaPacket_endTime_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_endTime_get", _wrap_MetaPacket_endTime_get, METH_VARARGS, NULL}, - { (char *)"MetaPacket_timestamp_set", _wrap_MetaPacket_timestamp_set, METH_VARARGS, NULL}, - { (char *)"MetaPacket_timestamp_get", _wrap_MetaPacket_timestamp_get, METH_VARARGS, NULL}, - { (char *)"new_MetaPacket", _wrap_new_MetaPacket, METH_VARARGS, NULL}, - { (char *)"delete_MetaPacket", _wrap_delete_MetaPacket, METH_VARARGS, NULL}, - { (char *)"MetaPacket_swigregister", MetaPacket_swigregister, METH_VARARGS, NULL}, - { (char *)"new_Packet", _wrap_new_Packet, METH_VARARGS, NULL}, - { (char *)"Packet_clone", _wrap_Packet_clone, METH_VARARGS, NULL}, - { (char *)"Packet_buffer_set", _wrap_Packet_buffer_set, METH_VARARGS, NULL}, - { (char *)"Packet_buffer_get", _wrap_Packet_buffer_get, METH_VARARGS, NULL}, - { (char *)"Packet_record_set", _wrap_Packet_record_set, METH_VARARGS, NULL}, - { (char *)"Packet_record_get", _wrap_Packet_record_get, METH_VARARGS, NULL}, - { (char *)"Packet_networkCode_set", _wrap_Packet_networkCode_set, METH_VARARGS, NULL}, - { (char *)"Packet_networkCode_get", _wrap_Packet_networkCode_get, METH_VARARGS, NULL}, - { (char *)"Packet_stationCode_set", _wrap_Packet_stationCode_set, METH_VARARGS, NULL}, - { (char *)"Packet_stationCode_get", _wrap_Packet_stationCode_get, METH_VARARGS, NULL}, - { (char *)"Packet_locationCode_set", _wrap_Packet_locationCode_set, METH_VARARGS, NULL}, - { (char *)"Packet_locationCode_get", _wrap_Packet_locationCode_get, METH_VARARGS, NULL}, - { (char *)"Packet_channelCode_set", _wrap_Packet_channelCode_set, METH_VARARGS, NULL}, - { (char *)"Packet_channelCode_get", _wrap_Packet_channelCode_get, METH_VARARGS, NULL}, - { (char *)"Packet_streamID_set", _wrap_Packet_streamID_set, METH_VARARGS, NULL}, - { (char *)"Packet_streamID_get", _wrap_Packet_streamID_get, METH_VARARGS, NULL}, - { (char *)"Packet_dataType_set", _wrap_Packet_dataType_set, METH_VARARGS, NULL}, - { (char *)"Packet_dataType_get", _wrap_Packet_dataType_get, METH_VARARGS, NULL}, - { (char *)"Packet_dt_us_set", _wrap_Packet_dt_us_set, METH_VARARGS, NULL}, - { (char *)"Packet_dt_us_get", _wrap_Packet_dt_us_get, METH_VARARGS, NULL}, - { (char *)"Packet_uom_set", _wrap_Packet_uom_set, METH_VARARGS, NULL}, - { (char *)"Packet_uom_get", _wrap_Packet_uom_get, METH_VARARGS, NULL}, - { (char *)"Packet_timingQuality_set", _wrap_Packet_timingQuality_set, METH_VARARGS, NULL}, - { (char *)"Packet_timingQuality_get", _wrap_Packet_timingQuality_get, METH_VARARGS, NULL}, - { (char *)"Packet_size", _wrap_Packet_size, METH_VARARGS, NULL}, - { (char *)"delete_Packet", _wrap_delete_Packet, METH_VARARGS, NULL}, - { (char *)"Packet_swigregister", Packet_swigregister, METH_VARARGS, NULL}, - { (char *)"new_AnyDataRecord", _wrap_new_AnyDataRecord, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_setType", _wrap_AnyDataRecord_setType, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_type", _wrap_AnyDataRecord_type, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_formatName", _wrap_AnyDataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_readMetaData", _wrap_AnyDataRecord_readMetaData, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_header", _wrap_AnyDataRecord_header, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_startTime", _wrap_AnyDataRecord_startTime, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_endTime", _wrap_AnyDataRecord_endTime, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_canTrim", _wrap_AnyDataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_canMerge", _wrap_AnyDataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_trim", _wrap_AnyDataRecord_trim, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_dataSize", _wrap_AnyDataRecord_dataSize, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_get", _wrap_AnyDataRecord_get, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_put", _wrap_AnyDataRecord_put, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_packetType", _wrap_AnyDataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_setStartTime", _wrap_AnyDataRecord_setStartTime, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_setEndTime", _wrap_AnyDataRecord_setEndTime, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_setSamplingFrequency", _wrap_AnyDataRecord_setSamplingFrequency, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_data", _wrap_AnyDataRecord_data, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_setData", _wrap_AnyDataRecord_setData, METH_VARARGS, NULL}, - { (char *)"delete_AnyDataRecord", _wrap_delete_AnyDataRecord, METH_VARARGS, NULL}, - { (char *)"AnyDataRecord_swigregister", AnyDataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"SetLogHandler", _wrap_SetLogHandler, METH_VARARGS, NULL}, - { (char *)"SPClock_freqn_get", _wrap_SPClock_freqn_get, METH_VARARGS, NULL}, - { (char *)"SPClock_freqd_get", _wrap_SPClock_freqd_get, METH_VARARGS, NULL}, - { (char *)"new_SPClock", _wrap_new_SPClock, METH_VARARGS, NULL}, - { (char *)"SPClock_sync_time", _wrap_SPClock_sync_time, METH_VARARGS, NULL}, - { (char *)"SPClock_tick", _wrap_SPClock_tick, METH_VARARGS, NULL}, - { (char *)"SPClock_get_time", _wrap_SPClock_get_time, METH_VARARGS, NULL}, - { (char *)"SPClock_correction", _wrap_SPClock_correction, METH_VARARGS, NULL}, - { (char *)"delete_SPClock", _wrap_delete_SPClock, METH_VARARGS, NULL}, - { (char *)"SPClock_swigregister", SPClock_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_Encoder", _wrap_delete_Encoder, METH_VARARGS, NULL}, - { (char *)"Encoder_push", _wrap_Encoder_push, METH_VARARGS, NULL}, - { (char *)"Encoder_flush", _wrap_Encoder_flush, METH_VARARGS, NULL}, - { (char *)"Encoder_reset", _wrap_Encoder_reset, METH_VARARGS, NULL}, - { (char *)"Encoder_type", _wrap_Encoder_type, METH_VARARGS, NULL}, - { (char *)"Encoder_clk", _wrap_Encoder_clk, METH_VARARGS, NULL}, - { (char *)"Encoder_setStartTime", _wrap_Encoder_setStartTime, METH_VARARGS, NULL}, - { (char *)"Encoder_currentTime", _wrap_Encoder_currentTime, METH_VARARGS, NULL}, - { (char *)"Encoder_timingQuality", _wrap_Encoder_timingQuality, METH_VARARGS, NULL}, - { (char *)"Encoder_setTimingQuality", _wrap_Encoder_setTimingQuality, METH_VARARGS, NULL}, - { (char *)"Encoder_pop", _wrap_Encoder_pop, METH_VARARGS, NULL}, - { (char *)"Encoder_swigregister", Encoder_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_EncoderFactory", _wrap_delete_EncoderFactory, METH_VARARGS, NULL}, - { (char *)"EncoderFactory_create", _wrap_EncoderFactory_create, METH_VARARGS, NULL}, - { (char *)"EncoderFactory_supportsRecord", _wrap_EncoderFactory_supportsRecord, METH_VARARGS, NULL}, - { (char *)"EncoderFactory_errorString", _wrap_EncoderFactory_errorString, METH_VARARGS, NULL}, - { (char *)"EncoderFactory_swigregister", EncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"MSEEDEncoderFactory_setRecordLength", _wrap_MSEEDEncoderFactory_setRecordLength, METH_VARARGS, NULL}, - { (char *)"delete_MSEEDEncoderFactory", _wrap_delete_MSEEDEncoderFactory, METH_VARARGS, NULL}, - { (char *)"MSEEDEncoderFactory_swigregister", MSEEDEncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"SteimEncoderFactory_supportsRecord", _wrap_SteimEncoderFactory_supportsRecord, METH_VARARGS, NULL}, - { (char *)"delete_SteimEncoderFactory", _wrap_delete_SteimEncoderFactory, METH_VARARGS, NULL}, - { (char *)"SteimEncoderFactory_swigregister", SteimEncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"IdentityEncoderFactory_create", _wrap_IdentityEncoderFactory_create, METH_VARARGS, NULL}, - { (char *)"IdentityEncoderFactory_supportsRecord", _wrap_IdentityEncoderFactory_supportsRecord, METH_VARARGS, NULL}, - { (char *)"new_IdentityEncoderFactory", _wrap_new_IdentityEncoderFactory, METH_VARARGS, NULL}, - { (char *)"delete_IdentityEncoderFactory", _wrap_delete_IdentityEncoderFactory, METH_VARARGS, NULL}, - { (char *)"IdentityEncoderFactory_swigregister", IdentityEncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"Steim1EncoderFactory_create", _wrap_Steim1EncoderFactory_create, METH_VARARGS, NULL}, - { (char *)"new_Steim1EncoderFactory", _wrap_new_Steim1EncoderFactory, METH_VARARGS, NULL}, - { (char *)"delete_Steim1EncoderFactory", _wrap_delete_Steim1EncoderFactory, METH_VARARGS, NULL}, - { (char *)"Steim1EncoderFactory_swigregister", Steim1EncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"Steim2EncoderFactory_create", _wrap_Steim2EncoderFactory_create, METH_VARARGS, NULL}, - { (char *)"new_Steim2EncoderFactory", _wrap_new_Steim2EncoderFactory, METH_VARARGS, NULL}, - { (char *)"delete_Steim2EncoderFactory", _wrap_delete_Steim2EncoderFactory, METH_VARARGS, NULL}, - { (char *)"Steim2EncoderFactory_swigregister", Steim2EncoderFactory_swigregister, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_formatName", _wrap_MSEEDDataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_readMetaData", _wrap_MSEEDDataRecord_readMetaData, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_header", _wrap_MSEEDDataRecord_header, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_startTime", _wrap_MSEEDDataRecord_startTime, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_endTime", _wrap_MSEEDDataRecord_endTime, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_canTrim", _wrap_MSEEDDataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_canMerge", _wrap_MSEEDDataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_trim", _wrap_MSEEDDataRecord_trim, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_dataSize", _wrap_MSEEDDataRecord_dataSize, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_get", _wrap_MSEEDDataRecord_get, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_put", _wrap_MSEEDDataRecord_put, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_packetType", _wrap_MSEEDDataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_setData", _wrap_MSEEDDataRecord_setData, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_unpackHeader", _wrap_MSEEDDataRecord_unpackHeader, METH_VARARGS, NULL}, - { (char *)"delete_MSEEDDataRecord", _wrap_delete_MSEEDDataRecord, METH_VARARGS, NULL}, - { (char *)"MSEEDDataRecord_swigregister", MSEEDDataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"new_Plugin", _wrap_new_Plugin, METH_VARARGS, NULL}, - { (char *)"delete_Plugin", _wrap_delete_Plugin, METH_VARARGS, NULL}, - { (char *)"Plugin_close", _wrap_Plugin_close, METH_VARARGS, NULL}, - { (char *)"Plugin_quit", _wrap_Plugin_quit, METH_VARARGS, NULL}, - { (char *)"Plugin_enableLogging", _wrap_Plugin_enableLogging, METH_VARARGS, NULL}, - { (char *)"Plugin_setBackfillingBufferSize", _wrap_Plugin_setBackfillingBufferSize, METH_VARARGS, NULL}, - { (char *)"Plugin_backfillingBufferSize", _wrap_Plugin_backfillingBufferSize, METH_VARARGS, NULL}, - { (char *)"Plugin_isExitRequested", _wrap_Plugin_isExitRequested, METH_VARARGS, NULL}, - { (char *)"Plugin_stats", _wrap_Plugin_stats, METH_VARARGS, NULL}, - { (char *)"Plugin_resetMaxBytesBuffered", _wrap_Plugin_resetMaxBytesBuffered, METH_VARARGS, NULL}, - { (char *)"Plugin_setEncoderFactory", _wrap_Plugin_setEncoderFactory, METH_VARARGS, NULL}, - { (char *)"Plugin_setHost", _wrap_Plugin_setHost, METH_VARARGS, NULL}, - { (char *)"Plugin_host", _wrap_Plugin_host, METH_VARARGS, NULL}, - { (char *)"Plugin_setPort", _wrap_Plugin_setPort, METH_VARARGS, NULL}, - { (char *)"Plugin_port", _wrap_Plugin_port, METH_VARARGS, NULL}, - { (char *)"Plugin_setBufferSize", _wrap_Plugin_setBufferSize, METH_VARARGS, NULL}, - { (char *)"Plugin_bufferSize", _wrap_Plugin_bufferSize, METH_VARARGS, NULL}, - { (char *)"Plugin_setSSLEnabled", _wrap_Plugin_setSSLEnabled, METH_VARARGS, NULL}, - { (char *)"Plugin_setCredentials", _wrap_Plugin_setCredentials, METH_VARARGS, NULL}, - { (char *)"Plugin_setMaxFutureEndTime", _wrap_Plugin_setMaxFutureEndTime, METH_VARARGS, NULL}, - { (char *)"Plugin_setPacketAckFunc", _wrap_Plugin_setPacketAckFunc, METH_VARARGS, NULL}, - { (char *)"Plugin_setSendTimeout", _wrap_Plugin_setSendTimeout, METH_VARARGS, NULL}, - { (char *)"Plugin_setTimeouts", _wrap_Plugin_setTimeouts, METH_VARARGS, NULL}, - { (char *)"Plugin_readJournal", _wrap_Plugin_readJournal, METH_VARARGS, NULL}, - { (char *)"Plugin_setJournal", _wrap_Plugin_setJournal, METH_VARARGS, NULL}, - { (char *)"Plugin_setFlushInterval", _wrap_Plugin_setFlushInterval, METH_VARARGS, NULL}, - { (char *)"Plugin_streamStates", _wrap_Plugin_streamStates, METH_VARARGS, NULL}, - { (char *)"Plugin_writeJournal", _wrap_Plugin_writeJournal, METH_VARARGS, NULL}, - { (char *)"Plugin_version", _wrap_Plugin_version, METH_VARARGS, NULL}, - { (char *)"Plugin_push", _wrap_Plugin_push, METH_VARARGS, NULL}, - { (char *)"Plugin_swigregister", Plugin_swigregister, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_timeSeconds_set", _wrap_RawResponseHeader_timeSeconds_set, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_timeSeconds_get", _wrap_RawResponseHeader_timeSeconds_get, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_timeMicroSeconds_set", _wrap_RawResponseHeader_timeMicroSeconds_set, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_timeMicroSeconds_get", _wrap_RawResponseHeader_timeMicroSeconds_get, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_get", _wrap_RawResponseHeader_get, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_dataSize", _wrap_RawResponseHeader_dataSize, METH_VARARGS, NULL}, - { (char *)"new_RawResponseHeader", _wrap_new_RawResponseHeader, METH_VARARGS, NULL}, - { (char *)"delete_RawResponseHeader", _wrap_delete_RawResponseHeader, METH_VARARGS, NULL}, - { (char *)"RawResponseHeader_swigregister", RawResponseHeader_swigregister, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_formatName", _wrap_RawDataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_readMetaData", _wrap_RawDataRecord_readMetaData, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_setHeader", _wrap_RawDataRecord_setHeader, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_header", _wrap_RawDataRecord_header, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_startTime", _wrap_RawDataRecord_startTime, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_endTime", _wrap_RawDataRecord_endTime, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_canTrim", _wrap_RawDataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_canMerge", _wrap_RawDataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_trim", _wrap_RawDataRecord_trim, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_dataSize", _wrap_RawDataRecord_dataSize, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_get", _wrap_RawDataRecord_get, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_getData", _wrap_RawDataRecord_getData, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_put", _wrap_RawDataRecord_put, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_packetType", _wrap_RawDataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_setStartTime", _wrap_RawDataRecord_setStartTime, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_setSamplingFrequency", _wrap_RawDataRecord_setSamplingFrequency, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_setDataType", _wrap_RawDataRecord_setDataType, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_setBuffer", _wrap_RawDataRecord_setBuffer, METH_VARARGS, NULL}, - { (char *)"delete_RawDataRecord", _wrap_delete_RawDataRecord, METH_VARARGS, NULL}, - { (char *)"RawDataRecord_swigregister", RawDataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_canTrim", _wrap_FixedRawDataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_canMerge", _wrap_FixedRawDataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_trim", _wrap_FixedRawDataRecord_trim, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_formatName", _wrap_FixedRawDataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_get", _wrap_FixedRawDataRecord_get, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_packetType", _wrap_FixedRawDataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"delete_FixedRawDataRecord", _wrap_delete_FixedRawDataRecord, METH_VARARGS, NULL}, - { (char *)"FixedRawDataRecord_swigregister", FixedRawDataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_chunkSize_set", _wrap_ChunkHeader_chunkSize_set, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_chunkSize_get", _wrap_ChunkHeader_chunkSize_get, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_setChunkType", _wrap_ChunkHeader_setChunkType, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_isChunkType", _wrap_ChunkHeader_isChunkType, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_validChunkType", _wrap_ChunkHeader_validChunkType, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_dataSize", _wrap_ChunkHeader_dataSize, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_read", _wrap_ChunkHeader_read, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_write", _wrap_ChunkHeader_write, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_get", _wrap_ChunkHeader_get, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_put", _wrap_ChunkHeader_put, METH_VARARGS, NULL}, - { (char *)"new_ChunkHeader", _wrap_new_ChunkHeader, METH_VARARGS, NULL}, - { (char *)"delete_ChunkHeader", _wrap_delete_ChunkHeader, METH_VARARGS, NULL}, - { (char *)"ChunkHeader_swigregister", ChunkHeader_swigregister, METH_VARARGS, NULL}, - { (char *)"new_ChunkIterator", _wrap_new_ChunkIterator, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_begin", _wrap_ChunkIterator_begin, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_next", _wrap_ChunkIterator_next, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_header", _wrap_ChunkIterator_header, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_headerPos", _wrap_ChunkIterator_headerPos, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_contentPos", _wrap_ChunkIterator_contentPos, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_istream", _wrap_ChunkIterator_istream, METH_VARARGS, NULL}, - { (char *)"delete_ChunkIterator", _wrap_delete_ChunkIterator, METH_VARARGS, NULL}, - { (char *)"ChunkIterator_swigregister", ChunkIterator_swigregister, METH_VARARGS, NULL}, - { (char *)"delete_Chunk", _wrap_delete_Chunk, METH_VARARGS, NULL}, - { (char *)"Chunk_read", _wrap_Chunk_read, METH_VARARGS, NULL}, - { (char *)"Chunk_write", _wrap_Chunk_write, METH_VARARGS, NULL}, - { (char *)"Chunk_get", _wrap_Chunk_get, METH_VARARGS, NULL}, - { (char *)"Chunk_put", _wrap_Chunk_put, METH_VARARGS, NULL}, - { (char *)"Chunk_chunkSize", _wrap_Chunk_chunkSize, METH_VARARGS, NULL}, - { (char *)"Chunk_swigregister", Chunk_swigregister, METH_VARARGS, NULL}, - { (char *)"HeadChunk_data_set", _wrap_HeadChunk_data_set, METH_VARARGS, NULL}, - { (char *)"HeadChunk_data_get", _wrap_HeadChunk_data_get, METH_VARARGS, NULL}, - { (char *)"HeadChunk_chunkSize", _wrap_HeadChunk_chunkSize, METH_VARARGS, NULL}, - { (char *)"HeadChunk_get", _wrap_HeadChunk_get, METH_VARARGS, NULL}, - { (char *)"HeadChunk_put", _wrap_HeadChunk_put, METH_VARARGS, NULL}, - { (char *)"new_HeadChunk", _wrap_new_HeadChunk, METH_VARARGS, NULL}, - { (char *)"delete_HeadChunk", _wrap_delete_HeadChunk, METH_VARARGS, NULL}, - { (char *)"HeadChunk_swigregister", HeadChunk_swigregister, METH_VARARGS, NULL}, - { (char *)"SID_networkCode_set", _wrap_SID_networkCode_set, METH_VARARGS, NULL}, - { (char *)"SID_networkCode_get", _wrap_SID_networkCode_get, METH_VARARGS, NULL}, - { (char *)"SID_stationCode_set", _wrap_SID_stationCode_set, METH_VARARGS, NULL}, - { (char *)"SID_stationCode_get", _wrap_SID_stationCode_get, METH_VARARGS, NULL}, - { (char *)"SID_locationCode_set", _wrap_SID_locationCode_set, METH_VARARGS, NULL}, - { (char *)"SID_locationCode_get", _wrap_SID_locationCode_get, METH_VARARGS, NULL}, - { (char *)"SID_channelCode_set", _wrap_SID_channelCode_set, METH_VARARGS, NULL}, - { (char *)"SID_channelCode_get", _wrap_SID_channelCode_get, METH_VARARGS, NULL}, - { (char *)"SID___eq__", _wrap_SID___eq__, METH_VARARGS, NULL}, - { (char *)"SID___ne__", _wrap_SID___ne__, METH_VARARGS, NULL}, - { (char *)"SID_toString", _wrap_SID_toString, METH_VARARGS, NULL}, - { (char *)"new_SID", _wrap_new_SID, METH_VARARGS, NULL}, - { (char *)"delete_SID", _wrap_delete_SID, METH_VARARGS, NULL}, - { (char *)"SID_swigregister", SID_swigregister, METH_VARARGS, NULL}, - { (char *)"SIDChunk_chunkSize", _wrap_SIDChunk_chunkSize, METH_VARARGS, NULL}, - { (char *)"SIDChunk_get", _wrap_SIDChunk_get, METH_VARARGS, NULL}, - { (char *)"SIDChunk_put", _wrap_SIDChunk_put, METH_VARARGS, NULL}, - { (char *)"new_SIDChunk", _wrap_new_SIDChunk, METH_VARARGS, NULL}, - { (char *)"delete_SIDChunk", _wrap_delete_SIDChunk, METH_VARARGS, NULL}, - { (char *)"SIDChunk_swigregister", SIDChunk_swigregister, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_formatName", _wrap_RTCM2DataRecord_formatName, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_setTimeStamp", _wrap_RTCM2DataRecord_setTimeStamp, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_setSamplingFrequency", _wrap_RTCM2DataRecord_setSamplingFrequency, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_readMetaData", _wrap_RTCM2DataRecord_readMetaData, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_header", _wrap_RTCM2DataRecord_header, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_startTime", _wrap_RTCM2DataRecord_startTime, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_endTime", _wrap_RTCM2DataRecord_endTime, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_canTrim", _wrap_RTCM2DataRecord_canTrim, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_canMerge", _wrap_RTCM2DataRecord_canMerge, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_trim", _wrap_RTCM2DataRecord_trim, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_dataSize", _wrap_RTCM2DataRecord_dataSize, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_get", _wrap_RTCM2DataRecord_get, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_put", _wrap_RTCM2DataRecord_put, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_packetType", _wrap_RTCM2DataRecord_packetType, METH_VARARGS, NULL}, - { (char *)"delete_RTCM2DataRecord", _wrap_delete_RTCM2DataRecord, METH_VARARGS, NULL}, - { (char *)"RTCM2DataRecord_swigregister", RTCM2DataRecord_swigregister, METH_VARARGS, NULL}, - { (char *)"new_Socket", _wrap_new_Socket, METH_VARARGS, NULL}, - { (char *)"delete_Socket", _wrap_delete_Socket, METH_VARARGS, NULL}, - { (char *)"Socket_toString", _wrap_Socket_toString, METH_VARARGS, NULL}, - { (char *)"Socket_fd", _wrap_Socket_fd, METH_VARARGS, NULL}, - { (char *)"Socket_isValid", _wrap_Socket_isValid, METH_VARARGS, NULL}, - { (char *)"Socket_shutdown", _wrap_Socket_shutdown, METH_VARARGS, NULL}, - { (char *)"Socket_close", _wrap_Socket_close, METH_VARARGS, NULL}, - { (char *)"Socket_send", _wrap_Socket_send, METH_VARARGS, NULL}, - { (char *)"Socket_write", _wrap_Socket_write, METH_VARARGS, NULL}, - { (char *)"Socket_read", _wrap_Socket_read, METH_VARARGS, NULL}, - { (char *)"Socket_flush", _wrap_Socket_flush, METH_VARARGS, NULL}, - { (char *)"Socket_setSocketTimeout", _wrap_Socket_setSocketTimeout, METH_VARARGS, NULL}, - { (char *)"Socket_setNonBlocking", _wrap_Socket_setNonBlocking, METH_VARARGS, NULL}, - { (char *)"Socket_connect", _wrap_Socket_connect, METH_VARARGS, NULL}, - { (char *)"Socket_rx", _wrap_Socket_rx, METH_VARARGS, NULL}, - { (char *)"Socket_tx", _wrap_Socket_tx, METH_VARARGS, NULL}, - { (char *)"Socket_swigregister", Socket_swigregister, METH_VARARGS, NULL}, - { (char *)"new_SSLSocket", _wrap_new_SSLSocket, METH_VARARGS, NULL}, - { (char *)"delete_SSLSocket", _wrap_delete_SSLSocket, METH_VARARGS, NULL}, - { (char *)"SSLSocket_write", _wrap_SSLSocket_write, METH_VARARGS, NULL}, - { (char *)"SSLSocket_read", _wrap_SSLSocket_read, METH_VARARGS, NULL}, - { (char *)"SSLSocket_connect", _wrap_SSLSocket_connect, METH_VARARGS, NULL}, - { (char *)"SSLSocket_sessionID", _wrap_SSLSocket_sessionID, METH_VARARGS, NULL}, - { (char *)"SSLSocket_sessionIDLength", _wrap_SSLSocket_sessionIDLength, METH_VARARGS, NULL}, - { (char *)"SSLSocket_peerCertificate", _wrap_SSLSocket_peerCertificate, METH_VARARGS, NULL}, - { (char *)"SSLSocket_swigregister", SSLSocket_swigregister, METH_VARARGS, NULL}, - { (char *)"new_charArray", _wrap_new_charArray, METH_VARARGS, NULL}, - { (char *)"delete_charArray", _wrap_delete_charArray, METH_VARARGS, NULL}, - { (char *)"charArray___getitem__", _wrap_charArray___getitem__, METH_VARARGS, NULL}, - { (char *)"charArray___setitem__", _wrap_charArray___setitem__, METH_VARARGS, NULL}, - { (char *)"charArray_cast", _wrap_charArray_cast, METH_VARARGS, NULL}, - { (char *)"charArray_frompointer", _wrap_charArray_frompointer, METH_VARARGS, NULL}, - { (char *)"charArray_swigregister", charArray_swigregister, METH_VARARGS, NULL}, - { (char *)"new_arraybuf", _wrap_new_arraybuf, METH_VARARGS, NULL}, - { (char *)"arraybuf_reset", _wrap_arraybuf_reset, METH_VARARGS, NULL}, - { (char *)"arraybuf_seekoff", _wrap_arraybuf_seekoff, METH_VARARGS, NULL}, - { (char *)"arraybuf_seekpos", _wrap_arraybuf_seekpos, METH_VARARGS, NULL}, - { (char *)"arraybuf_xsgetn", _wrap_arraybuf_xsgetn, METH_VARARGS, NULL}, - { (char *)"arraybuf_tellg", _wrap_arraybuf_tellg, METH_VARARGS, NULL}, - { (char *)"arraybuf_tellp", _wrap_arraybuf_tellp, METH_VARARGS, NULL}, - { (char *)"delete_arraybuf", _wrap_delete_arraybuf, METH_VARARGS, NULL}, - { (char *)"arraybuf_swigregister", arraybuf_swigregister, METH_VARARGS, NULL}, - { (char *)"splitAddress", _wrap_splitAddress, METH_VARARGS, NULL}, - { (char *)"tokenize", _wrap_tokenize, METH_VARARGS, NULL}, - { (char *)"trim", _wrap_trim, METH_VARARGS, NULL}, - { (char *)"timeToTimestamp", _wrap_timeToTimestamp, METH_VARARGS, NULL}, - { (char *)"str2int", _wrap_str2int, METH_VARARGS, NULL}, - { (char *)"timestampToTime", _wrap_timestampToTime, METH_VARARGS, NULL}, - { (char *)"samplesToTimeSpan", _wrap_samplesToTimeSpan, METH_VARARGS, NULL}, - { (char *)"timeSpanToSamples", _wrap_timeSpanToSamples, METH_VARARGS, NULL}, - { (char *)"timeSpanToSamplesCeil", _wrap_timeSpanToSamplesCeil, METH_VARARGS, NULL}, - { (char *)"timeSpanToSamplesFloor", _wrap_timeSpanToSamplesFloor, METH_VARARGS, NULL}, - { (char *)"dataTypeSize", _wrap_dataTypeSize, METH_VARARGS, NULL}, + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "new_TimeSpan", _wrap_new_TimeSpan, METH_VARARGS, NULL}, + { "TimeSpan___eq__", _wrap_TimeSpan___eq__, METH_VARARGS, NULL}, + { "TimeSpan___ne__", _wrap_TimeSpan___ne__, METH_VARARGS, NULL}, + { "TimeSpan___lt__", _wrap_TimeSpan___lt__, METH_VARARGS, NULL}, + { "TimeSpan___le__", _wrap_TimeSpan___le__, METH_VARARGS, NULL}, + { "TimeSpan___gt__", _wrap_TimeSpan___gt__, METH_VARARGS, NULL}, + { "TimeSpan___ge__", _wrap_TimeSpan___ge__, METH_VARARGS, NULL}, + { "TimeSpan___add__", _wrap_TimeSpan___add__, METH_VARARGS, NULL}, + { "TimeSpan___sub__", _wrap_TimeSpan___sub__, METH_VARARGS, NULL}, + { "TimeSpan___iadd__", _wrap_TimeSpan___iadd__, METH_VARARGS, NULL}, + { "TimeSpan___isub__", _wrap_TimeSpan___isub__, METH_VARARGS, NULL}, + { "TimeSpan_abs", _wrap_TimeSpan_abs, METH_O, NULL}, + { "TimeSpan_seconds", _wrap_TimeSpan_seconds, METH_O, NULL}, + { "TimeSpan_microseconds", _wrap_TimeSpan_microseconds, METH_O, NULL}, + { "TimeSpan_length", _wrap_TimeSpan_length, METH_O, NULL}, + { "TimeSpan_set", _wrap_TimeSpan_set, METH_VARARGS, NULL}, + { "TimeSpan_setUSecs", _wrap_TimeSpan_setUSecs, METH_VARARGS, NULL}, + { "TimeSpan_elapsedTime", _wrap_TimeSpan_elapsedTime, METH_VARARGS, NULL}, + { "delete_TimeSpan", _wrap_delete_TimeSpan, METH_O, NULL}, + { "TimeSpan_swigregister", TimeSpan_swigregister, METH_O, NULL}, + { "TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL}, + { "new_Time", _wrap_new_Time, METH_VARARGS, NULL}, + { "Time___nonzero__", _wrap_Time___nonzero__, METH_O, NULL}, + { "Time___add__", _wrap_Time___add__, METH_VARARGS, NULL}, + { "Time___sub__", _wrap_Time___sub__, METH_VARARGS, NULL}, + { "Time___iadd__", _wrap_Time___iadd__, METH_VARARGS, NULL}, + { "Time___isub__", _wrap_Time___isub__, METH_VARARGS, NULL}, + { "Time_set", _wrap_Time_set, METH_VARARGS, NULL}, + { "Time_get", _wrap_Time_get, METH_VARARGS, NULL}, + { "Time_get2", _wrap_Time_get2, METH_VARARGS, NULL}, + { "Time_LocalTime", _wrap_Time_LocalTime, METH_NOARGS, NULL}, + { "Time_GMT", _wrap_Time_GMT, METH_NOARGS, NULL}, + { "Time_FromYearDay", _wrap_Time_FromYearDay, METH_VARARGS, NULL}, + { "Time_localtime", _wrap_Time_localtime, METH_O, NULL}, + { "Time_gmt", _wrap_Time_gmt, METH_O, NULL}, + { "Time_toLocalTime", _wrap_Time_toLocalTime, METH_O, NULL}, + { "Time_toGMT", _wrap_Time_toGMT, METH_O, NULL}, + { "Time_valid", _wrap_Time_valid, METH_O, NULL}, + { "Time_toString", _wrap_Time_toString, METH_VARARGS, NULL}, + { "Time_iso", _wrap_Time_iso, METH_O, NULL}, + { "Time_fromString", _wrap_Time_fromString, METH_VARARGS, NULL}, + { "Time_FromString", _wrap_Time_FromString, METH_VARARGS, NULL}, + { "delete_Time", _wrap_delete_Time, METH_O, NULL}, + { "Time_swigregister", Time_swigregister, METH_O, NULL}, + { "Time_swiginit", Time_swiginit, METH_VARARGS, NULL}, + { "UOM_str_set", _wrap_UOM_str_set, METH_VARARGS, NULL}, + { "UOM_str_get", _wrap_UOM_str_get, METH_O, NULL}, + { "UOM_ID_set", _wrap_UOM_ID_set, METH_VARARGS, NULL}, + { "UOM_ID_get", _wrap_UOM_ID_get, METH_O, NULL}, + { "new_UOM", _wrap_new_UOM, METH_NOARGS, NULL}, + { "delete_UOM", _wrap_delete_UOM, METH_O, NULL}, + { "UOM_swigregister", UOM_swigregister, METH_O, NULL}, + { "UOM_swiginit", UOM_swiginit, METH_VARARGS, NULL}, + { "Quality_str_set", _wrap_Quality_str_set, METH_VARARGS, NULL}, + { "Quality_str_get", _wrap_Quality_str_get, METH_O, NULL}, + { "Quality_ID_set", _wrap_Quality_ID_set, METH_VARARGS, NULL}, + { "Quality_ID_get", _wrap_Quality_ID_get, METH_O, NULL}, + { "new_Quality", _wrap_new_Quality, METH_NOARGS, NULL}, + { "delete_Quality", _wrap_delete_Quality, METH_O, NULL}, + { "Quality_swigregister", Quality_swigregister, METH_O, NULL}, + { "Quality_swiginit", Quality_swiginit, METH_VARARGS, NULL}, + { "TimeStamp_year_set", _wrap_TimeStamp_year_set, METH_VARARGS, NULL}, + { "TimeStamp_year_get", _wrap_TimeStamp_year_get, METH_O, NULL}, + { "TimeStamp_yday_set", _wrap_TimeStamp_yday_set, METH_VARARGS, NULL}, + { "TimeStamp_yday_get", _wrap_TimeStamp_yday_get, METH_O, NULL}, + { "TimeStamp_hour_set", _wrap_TimeStamp_hour_set, METH_VARARGS, NULL}, + { "TimeStamp_hour_get", _wrap_TimeStamp_hour_get, METH_O, NULL}, + { "TimeStamp_minute_set", _wrap_TimeStamp_minute_set, METH_VARARGS, NULL}, + { "TimeStamp_minute_get", _wrap_TimeStamp_minute_get, METH_O, NULL}, + { "TimeStamp_second_set", _wrap_TimeStamp_second_set, METH_VARARGS, NULL}, + { "TimeStamp_second_get", _wrap_TimeStamp_second_get, METH_O, NULL}, + { "TimeStamp_unused_set", _wrap_TimeStamp_unused_set, METH_VARARGS, NULL}, + { "TimeStamp_unused_get", _wrap_TimeStamp_unused_get, METH_O, NULL}, + { "TimeStamp_usec_set", _wrap_TimeStamp_usec_set, METH_VARARGS, NULL}, + { "TimeStamp_usec_get", _wrap_TimeStamp_usec_get, METH_O, NULL}, + { "new_TimeStamp", _wrap_new_TimeStamp, METH_NOARGS, NULL}, + { "delete_TimeStamp", _wrap_delete_TimeStamp, METH_O, NULL}, + { "TimeStamp_swigregister", TimeStamp_swigregister, METH_O, NULL}, + { "TimeStamp_swiginit", TimeStamp_swiginit, METH_VARARGS, NULL}, + { "new_PacketDataHeader", _wrap_new_PacketDataHeader, METH_VARARGS, NULL}, + { "PacketDataHeader_version_set", _wrap_PacketDataHeader_version_set, METH_VARARGS, NULL}, + { "PacketDataHeader_version_get", _wrap_PacketDataHeader_version_get, METH_O, NULL}, + { "PacketDataHeader_packetType_set", _wrap_PacketDataHeader_packetType_set, METH_VARARGS, NULL}, + { "PacketDataHeader_packetType_get", _wrap_PacketDataHeader_packetType_get, METH_O, NULL}, + { "PacketDataHeader_unitOfMeasurement_set", _wrap_PacketDataHeader_unitOfMeasurement_set, METH_VARARGS, NULL}, + { "PacketDataHeader_unitOfMeasurement_get", _wrap_PacketDataHeader_unitOfMeasurement_get, METH_O, NULL}, + { "PacketDataHeader_setUOM", _wrap_PacketDataHeader_setUOM, METH_VARARGS, NULL}, + { "PacketDataHeader_uom", _wrap_PacketDataHeader_uom, METH_VARARGS, NULL}, + { "PacketDataHeader___ne__", _wrap_PacketDataHeader___ne__, METH_VARARGS, NULL}, + { "PacketDataHeader_dataSize", _wrap_PacketDataHeader_dataSize, METH_O, NULL}, + { "PacketDataHeader_put", _wrap_PacketDataHeader_put, METH_VARARGS, NULL}, + { "PacketDataHeader_get", _wrap_PacketDataHeader_get, METH_VARARGS, NULL}, + { "delete_PacketDataHeader", _wrap_delete_PacketDataHeader, METH_O, NULL}, + { "PacketDataHeader_swigregister", PacketDataHeader_swigregister, METH_O, NULL}, + { "PacketDataHeader_swiginit", PacketDataHeader_swiginit, METH_VARARGS, NULL}, + { "new_PacketDataHeaderV2", _wrap_new_PacketDataHeaderV2, METH_NOARGS, NULL}, + { "PacketDataHeaderV2_samplingFrequencyNumerator_set", _wrap_PacketDataHeaderV2_samplingFrequencyNumerator_set, METH_VARARGS, NULL}, + { "PacketDataHeaderV2_samplingFrequencyNumerator_get", _wrap_PacketDataHeaderV2_samplingFrequencyNumerator_get, METH_O, NULL}, + { "PacketDataHeaderV2_samplingFrequencyDenominator_set", _wrap_PacketDataHeaderV2_samplingFrequencyDenominator_set, METH_VARARGS, NULL}, + { "PacketDataHeaderV2_samplingFrequencyDenominator_get", _wrap_PacketDataHeaderV2_samplingFrequencyDenominator_get, METH_O, NULL}, + { "PacketDataHeaderV2_quality_set", _wrap_PacketDataHeaderV2_quality_set, METH_VARARGS, NULL}, + { "PacketDataHeaderV2_quality_get", _wrap_PacketDataHeaderV2_quality_get, METH_O, NULL}, + { "PacketDataHeaderV2___ne__", _wrap_PacketDataHeaderV2___ne__, METH_VARARGS, NULL}, + { "PacketDataHeaderV2_dataSize", _wrap_PacketDataHeaderV2_dataSize, METH_O, NULL}, + { "PacketDataHeaderV2_put", _wrap_PacketDataHeaderV2_put, METH_VARARGS, NULL}, + { "PacketDataHeaderV2_get", _wrap_PacketDataHeaderV2_get, METH_VARARGS, NULL}, + { "delete_PacketDataHeaderV2", _wrap_delete_PacketDataHeaderV2, METH_O, NULL}, + { "PacketDataHeaderV2_swigregister", PacketDataHeaderV2_swigregister, METH_O, NULL}, + { "PacketDataHeaderV2_swiginit", PacketDataHeaderV2_swiginit, METH_VARARGS, NULL}, + { "PacketHeaderV1_SIDSize_set", _wrap_PacketHeaderV1_SIDSize_set, METH_VARARGS, NULL}, + { "PacketHeaderV1_SIDSize_get", _wrap_PacketHeaderV1_SIDSize_get, METH_O, NULL}, + { "PacketHeaderV1_size_set", _wrap_PacketHeaderV1_size_set, METH_VARARGS, NULL}, + { "PacketHeaderV1_size_get", _wrap_PacketHeaderV1_size_get, METH_O, NULL}, + { "PacketHeaderV1_put", _wrap_PacketHeaderV1_put, METH_VARARGS, NULL}, + { "PacketHeaderV1_dataSize", _wrap_PacketHeaderV1_dataSize, METH_O, NULL}, + { "new_PacketHeaderV1", _wrap_new_PacketHeaderV1, METH_NOARGS, NULL}, + { "delete_PacketHeaderV1", _wrap_delete_PacketHeaderV1, METH_O, NULL}, + { "PacketHeaderV1_swigregister", PacketHeaderV1_swigregister, METH_O, NULL}, + { "PacketHeaderV1_swiginit", PacketHeaderV1_swiginit, METH_VARARGS, NULL}, + { "PacketHeaderV2_SIDSize_set", _wrap_PacketHeaderV2_SIDSize_set, METH_VARARGS, NULL}, + { "PacketHeaderV2_SIDSize_get", _wrap_PacketHeaderV2_SIDSize_get, METH_O, NULL}, + { "PacketHeaderV2_size_set", _wrap_PacketHeaderV2_size_set, METH_VARARGS, NULL}, + { "PacketHeaderV2_size_get", _wrap_PacketHeaderV2_size_get, METH_O, NULL}, + { "PacketHeaderV2_put", _wrap_PacketHeaderV2_put, METH_VARARGS, NULL}, + { "PacketHeaderV2_dataSize", _wrap_PacketHeaderV2_dataSize, METH_O, NULL}, + { "new_PacketHeaderV2", _wrap_new_PacketHeaderV2, METH_NOARGS, NULL}, + { "delete_PacketHeaderV2", _wrap_delete_PacketHeaderV2, METH_O, NULL}, + { "PacketHeaderV2_swigregister", PacketHeaderV2_swigregister, METH_O, NULL}, + { "PacketHeaderV2_swiginit", PacketHeaderV2_swiginit, METH_VARARGS, NULL}, + { "ResponseHeader_id_set", _wrap_ResponseHeader_id_set, METH_VARARGS, NULL}, + { "ResponseHeader_id_get", _wrap_ResponseHeader_id_get, METH_O, NULL}, + { "ResponseHeader_size_set", _wrap_ResponseHeader_size_set, METH_VARARGS, NULL}, + { "ResponseHeader_size_get", _wrap_ResponseHeader_size_get, METH_O, NULL}, + { "ResponseHeader_get", _wrap_ResponseHeader_get, METH_VARARGS, NULL}, + { "new_ResponseHeader", _wrap_new_ResponseHeader, METH_NOARGS, NULL}, + { "delete_ResponseHeader", _wrap_delete_ResponseHeader, METH_O, NULL}, + { "ResponseHeader_swigregister", ResponseHeader_swigregister, METH_O, NULL}, + { "ResponseHeader_swiginit", ResponseHeader_swiginit, METH_VARARGS, NULL}, + { "delete_DataRecord", _wrap_delete_DataRecord, METH_O, NULL}, + { "DataRecord_formatName", _wrap_DataRecord_formatName, METH_O, NULL}, + { "DataRecord_readMetaData", _wrap_DataRecord_readMetaData, METH_VARARGS, NULL}, + { "DataRecord_canTrim", _wrap_DataRecord_canTrim, METH_O, NULL}, + { "DataRecord_canMerge", _wrap_DataRecord_canMerge, METH_O, NULL}, + { "DataRecord_trim", _wrap_DataRecord_trim, METH_VARARGS, NULL}, + { "DataRecord_dataSize", _wrap_DataRecord_dataSize, METH_VARARGS, NULL}, + { "DataRecord_get", _wrap_DataRecord_get, METH_VARARGS, NULL}, + { "DataRecord_put", _wrap_DataRecord_put, METH_VARARGS, NULL}, + { "DataRecord_header", _wrap_DataRecord_header, METH_O, NULL}, + { "DataRecord_startTime", _wrap_DataRecord_startTime, METH_O, NULL}, + { "DataRecord_endTime", _wrap_DataRecord_endTime, METH_O, NULL}, + { "DataRecord_packetType", _wrap_DataRecord_packetType, METH_O, NULL}, + { "DataRecord_buffer", _wrap_DataRecord_buffer, METH_O, NULL}, + { "DataRecord_data", _wrap_DataRecord_data, METH_O, NULL}, + { "DataRecord_swigregister", DataRecord_swigregister, METH_O, NULL}, + { "RawPacket_header_set", _wrap_RawPacket_header_set, METH_VARARGS, NULL}, + { "RawPacket_header_get", _wrap_RawPacket_header_get, METH_O, NULL}, + { "RawPacket_SID_set", _wrap_RawPacket_SID_set, METH_VARARGS, NULL}, + { "RawPacket_SID_get", _wrap_RawPacket_SID_get, METH_O, NULL}, + { "RawPacket_data_set", _wrap_RawPacket_data_set, METH_VARARGS, NULL}, + { "RawPacket_data_get", _wrap_RawPacket_data_get, METH_O, NULL}, + { "RawPacket_record_set", _wrap_RawPacket_record_set, METH_VARARGS, NULL}, + { "RawPacket_record_get", _wrap_RawPacket_record_get, METH_O, NULL}, + { "new_RawPacket", _wrap_new_RawPacket, METH_NOARGS, NULL}, + { "delete_RawPacket", _wrap_delete_RawPacket, METH_O, NULL}, + { "RawPacket_swigregister", RawPacket_swigregister, METH_O, NULL}, + { "RawPacket_swiginit", RawPacket_swiginit, METH_VARARGS, NULL}, + { "MetaPacket_SID_set", _wrap_MetaPacket_SID_set, METH_VARARGS, NULL}, + { "MetaPacket_SID_get", _wrap_MetaPacket_SID_get, METH_O, NULL}, + { "MetaPacket_packetDataHeader_set", _wrap_MetaPacket_packetDataHeader_set, METH_VARARGS, NULL}, + { "MetaPacket_packetDataHeader_get", _wrap_MetaPacket_packetDataHeader_get, METH_O, NULL}, + { "MetaPacket_record_set", _wrap_MetaPacket_record_set, METH_VARARGS, NULL}, + { "MetaPacket_record_get", _wrap_MetaPacket_record_get, METH_O, NULL}, + { "MetaPacket_recordHeader_set", _wrap_MetaPacket_recordHeader_set, METH_VARARGS, NULL}, + { "MetaPacket_recordHeader_get", _wrap_MetaPacket_recordHeader_get, METH_O, NULL}, + { "MetaPacket_startTime_set", _wrap_MetaPacket_startTime_set, METH_VARARGS, NULL}, + { "MetaPacket_startTime_get", _wrap_MetaPacket_startTime_get, METH_O, NULL}, + { "MetaPacket_endTime_set", _wrap_MetaPacket_endTime_set, METH_VARARGS, NULL}, + { "MetaPacket_endTime_get", _wrap_MetaPacket_endTime_get, METH_O, NULL}, + { "MetaPacket_timestamp_set", _wrap_MetaPacket_timestamp_set, METH_VARARGS, NULL}, + { "MetaPacket_timestamp_get", _wrap_MetaPacket_timestamp_get, METH_O, NULL}, + { "new_MetaPacket", _wrap_new_MetaPacket, METH_NOARGS, NULL}, + { "delete_MetaPacket", _wrap_delete_MetaPacket, METH_O, NULL}, + { "MetaPacket_swigregister", MetaPacket_swigregister, METH_O, NULL}, + { "MetaPacket_swiginit", MetaPacket_swiginit, METH_VARARGS, NULL}, + { "new_Packet", _wrap_new_Packet, METH_VARARGS, NULL}, + { "Packet_clone", _wrap_Packet_clone, METH_O, NULL}, + { "Packet_buffer_set", _wrap_Packet_buffer_set, METH_VARARGS, NULL}, + { "Packet_buffer_get", _wrap_Packet_buffer_get, METH_O, NULL}, + { "Packet_record_set", _wrap_Packet_record_set, METH_VARARGS, NULL}, + { "Packet_record_get", _wrap_Packet_record_get, METH_O, NULL}, + { "Packet_networkCode_set", _wrap_Packet_networkCode_set, METH_VARARGS, NULL}, + { "Packet_networkCode_get", _wrap_Packet_networkCode_get, METH_O, NULL}, + { "Packet_stationCode_set", _wrap_Packet_stationCode_set, METH_VARARGS, NULL}, + { "Packet_stationCode_get", _wrap_Packet_stationCode_get, METH_O, NULL}, + { "Packet_locationCode_set", _wrap_Packet_locationCode_set, METH_VARARGS, NULL}, + { "Packet_locationCode_get", _wrap_Packet_locationCode_get, METH_O, NULL}, + { "Packet_channelCode_set", _wrap_Packet_channelCode_set, METH_VARARGS, NULL}, + { "Packet_channelCode_get", _wrap_Packet_channelCode_get, METH_O, NULL}, + { "Packet_streamID_set", _wrap_Packet_streamID_set, METH_VARARGS, NULL}, + { "Packet_streamID_get", _wrap_Packet_streamID_get, METH_O, NULL}, + { "Packet_dataType_set", _wrap_Packet_dataType_set, METH_VARARGS, NULL}, + { "Packet_dataType_get", _wrap_Packet_dataType_get, METH_O, NULL}, + { "Packet_dt_us_set", _wrap_Packet_dt_us_set, METH_VARARGS, NULL}, + { "Packet_dt_us_get", _wrap_Packet_dt_us_get, METH_O, NULL}, + { "Packet_uom_set", _wrap_Packet_uom_set, METH_VARARGS, NULL}, + { "Packet_uom_get", _wrap_Packet_uom_get, METH_O, NULL}, + { "Packet_timingQuality_set", _wrap_Packet_timingQuality_set, METH_VARARGS, NULL}, + { "Packet_timingQuality_get", _wrap_Packet_timingQuality_get, METH_O, NULL}, + { "Packet_size", _wrap_Packet_size, METH_O, NULL}, + { "delete_Packet", _wrap_delete_Packet, METH_O, NULL}, + { "Packet_swigregister", Packet_swigregister, METH_O, NULL}, + { "Packet_swiginit", Packet_swiginit, METH_VARARGS, NULL}, + { "new_AnyDataRecord", _wrap_new_AnyDataRecord, METH_NOARGS, NULL}, + { "AnyDataRecord_setType", _wrap_AnyDataRecord_setType, METH_VARARGS, NULL}, + { "AnyDataRecord_type", _wrap_AnyDataRecord_type, METH_O, NULL}, + { "AnyDataRecord_formatName", _wrap_AnyDataRecord_formatName, METH_O, NULL}, + { "AnyDataRecord_readMetaData", _wrap_AnyDataRecord_readMetaData, METH_VARARGS, NULL}, + { "AnyDataRecord_header", _wrap_AnyDataRecord_header, METH_O, NULL}, + { "AnyDataRecord_startTime", _wrap_AnyDataRecord_startTime, METH_O, NULL}, + { "AnyDataRecord_endTime", _wrap_AnyDataRecord_endTime, METH_O, NULL}, + { "AnyDataRecord_canTrim", _wrap_AnyDataRecord_canTrim, METH_O, NULL}, + { "AnyDataRecord_canMerge", _wrap_AnyDataRecord_canMerge, METH_O, NULL}, + { "AnyDataRecord_trim", _wrap_AnyDataRecord_trim, METH_VARARGS, NULL}, + { "AnyDataRecord_dataSize", _wrap_AnyDataRecord_dataSize, METH_VARARGS, NULL}, + { "AnyDataRecord_get", _wrap_AnyDataRecord_get, METH_VARARGS, NULL}, + { "AnyDataRecord_put", _wrap_AnyDataRecord_put, METH_VARARGS, NULL}, + { "AnyDataRecord_packetType", _wrap_AnyDataRecord_packetType, METH_O, NULL}, + { "AnyDataRecord_setStartTime", _wrap_AnyDataRecord_setStartTime, METH_VARARGS, NULL}, + { "AnyDataRecord_setEndTime", _wrap_AnyDataRecord_setEndTime, METH_VARARGS, NULL}, + { "AnyDataRecord_setSamplingFrequency", _wrap_AnyDataRecord_setSamplingFrequency, METH_VARARGS, NULL}, + { "AnyDataRecord_data", _wrap_AnyDataRecord_data, METH_O, NULL}, + { "AnyDataRecord_setData", _wrap_AnyDataRecord_setData, METH_VARARGS, NULL}, + { "delete_AnyDataRecord", _wrap_delete_AnyDataRecord, METH_O, NULL}, + { "AnyDataRecord_swigregister", AnyDataRecord_swigregister, METH_O, NULL}, + { "AnyDataRecord_swiginit", AnyDataRecord_swiginit, METH_VARARGS, NULL}, + { "SetLogHandler", _wrap_SetLogHandler, METH_VARARGS, NULL}, + { "new_SPClock", _wrap_new_SPClock, METH_VARARGS, NULL}, + { "SPClock_syncTime", _wrap_SPClock_syncTime, METH_VARARGS, NULL}, + { "SPClock_tick", _wrap_SPClock_tick, METH_O, NULL}, + { "SPClock_getTime", _wrap_SPClock_getTime, METH_VARARGS, NULL}, + { "SPClock_correction", _wrap_SPClock_correction, METH_O, NULL}, + { "SPClock_freqn_get", _wrap_SPClock_freqn_get, METH_O, NULL}, + { "SPClock_freqd_get", _wrap_SPClock_freqd_get, METH_O, NULL}, + { "delete_SPClock", _wrap_delete_SPClock, METH_O, NULL}, + { "SPClock_swigregister", SPClock_swigregister, METH_O, NULL}, + { "SPClock_swiginit", SPClock_swiginit, METH_VARARGS, NULL}, + { "delete_Encoder", _wrap_delete_Encoder, METH_O, NULL}, + { "Encoder_push", _wrap_Encoder_push, METH_VARARGS, NULL}, + { "Encoder_flush", _wrap_Encoder_flush, METH_O, NULL}, + { "Encoder_reset", _wrap_Encoder_reset, METH_O, NULL}, + { "Encoder_type", _wrap_Encoder_type, METH_O, NULL}, + { "Encoder_clk", _wrap_Encoder_clk, METH_O, NULL}, + { "Encoder_setStartTime", _wrap_Encoder_setStartTime, METH_VARARGS, NULL}, + { "Encoder_currentTime", _wrap_Encoder_currentTime, METH_O, NULL}, + { "Encoder_timingQuality", _wrap_Encoder_timingQuality, METH_O, NULL}, + { "Encoder_setTimingQuality", _wrap_Encoder_setTimingQuality, METH_VARARGS, NULL}, + { "Encoder_pop", _wrap_Encoder_pop, METH_O, NULL}, + { "Encoder_swigregister", Encoder_swigregister, METH_O, NULL}, + { "delete_EncoderFactory", _wrap_delete_EncoderFactory, METH_O, NULL}, + { "EncoderFactory_create", _wrap_EncoderFactory_create, METH_VARARGS, NULL}, + { "EncoderFactory_supportsRecord", _wrap_EncoderFactory_supportsRecord, METH_VARARGS, NULL}, + { "EncoderFactory_errorString", _wrap_EncoderFactory_errorString, METH_O, NULL}, + { "EncoderFactory_swigregister", EncoderFactory_swigregister, METH_O, NULL}, + { "MSEEDEncoderFactory_setRecordLength", _wrap_MSEEDEncoderFactory_setRecordLength, METH_VARARGS, NULL}, + { "delete_MSEEDEncoderFactory", _wrap_delete_MSEEDEncoderFactory, METH_O, NULL}, + { "MSEEDEncoderFactory_swigregister", MSEEDEncoderFactory_swigregister, METH_O, NULL}, + { "SteimEncoderFactory_supportsRecord", _wrap_SteimEncoderFactory_supportsRecord, METH_VARARGS, NULL}, + { "delete_SteimEncoderFactory", _wrap_delete_SteimEncoderFactory, METH_O, NULL}, + { "SteimEncoderFactory_swigregister", SteimEncoderFactory_swigregister, METH_O, NULL}, + { "IdentityEncoderFactory_create", _wrap_IdentityEncoderFactory_create, METH_VARARGS, NULL}, + { "IdentityEncoderFactory_supportsRecord", _wrap_IdentityEncoderFactory_supportsRecord, METH_VARARGS, NULL}, + { "new_IdentityEncoderFactory", _wrap_new_IdentityEncoderFactory, METH_NOARGS, NULL}, + { "delete_IdentityEncoderFactory", _wrap_delete_IdentityEncoderFactory, METH_O, NULL}, + { "IdentityEncoderFactory_swigregister", IdentityEncoderFactory_swigregister, METH_O, NULL}, + { "IdentityEncoderFactory_swiginit", IdentityEncoderFactory_swiginit, METH_VARARGS, NULL}, + { "Steim1EncoderFactory_create", _wrap_Steim1EncoderFactory_create, METH_VARARGS, NULL}, + { "new_Steim1EncoderFactory", _wrap_new_Steim1EncoderFactory, METH_NOARGS, NULL}, + { "delete_Steim1EncoderFactory", _wrap_delete_Steim1EncoderFactory, METH_O, NULL}, + { "Steim1EncoderFactory_swigregister", Steim1EncoderFactory_swigregister, METH_O, NULL}, + { "Steim1EncoderFactory_swiginit", Steim1EncoderFactory_swiginit, METH_VARARGS, NULL}, + { "Steim2EncoderFactory_create", _wrap_Steim2EncoderFactory_create, METH_VARARGS, NULL}, + { "new_Steim2EncoderFactory", _wrap_new_Steim2EncoderFactory, METH_NOARGS, NULL}, + { "delete_Steim2EncoderFactory", _wrap_delete_Steim2EncoderFactory, METH_O, NULL}, + { "Steim2EncoderFactory_swigregister", Steim2EncoderFactory_swigregister, METH_O, NULL}, + { "Steim2EncoderFactory_swiginit", Steim2EncoderFactory_swiginit, METH_VARARGS, NULL}, + { "MSEEDDataRecord_formatName", _wrap_MSEEDDataRecord_formatName, METH_O, NULL}, + { "MSEEDDataRecord_readMetaData", _wrap_MSEEDDataRecord_readMetaData, METH_VARARGS, NULL}, + { "MSEEDDataRecord_header", _wrap_MSEEDDataRecord_header, METH_O, NULL}, + { "MSEEDDataRecord_startTime", _wrap_MSEEDDataRecord_startTime, METH_O, NULL}, + { "MSEEDDataRecord_endTime", _wrap_MSEEDDataRecord_endTime, METH_O, NULL}, + { "MSEEDDataRecord_canTrim", _wrap_MSEEDDataRecord_canTrim, METH_O, NULL}, + { "MSEEDDataRecord_canMerge", _wrap_MSEEDDataRecord_canMerge, METH_O, NULL}, + { "MSEEDDataRecord_trim", _wrap_MSEEDDataRecord_trim, METH_VARARGS, NULL}, + { "MSEEDDataRecord_dataSize", _wrap_MSEEDDataRecord_dataSize, METH_VARARGS, NULL}, + { "MSEEDDataRecord_get", _wrap_MSEEDDataRecord_get, METH_VARARGS, NULL}, + { "MSEEDDataRecord_put", _wrap_MSEEDDataRecord_put, METH_VARARGS, NULL}, + { "MSEEDDataRecord_packetType", _wrap_MSEEDDataRecord_packetType, METH_O, NULL}, + { "MSEEDDataRecord_setData", _wrap_MSEEDDataRecord_setData, METH_VARARGS, NULL}, + { "MSEEDDataRecord_unpackHeader", _wrap_MSEEDDataRecord_unpackHeader, METH_O, NULL}, + { "delete_MSEEDDataRecord", _wrap_delete_MSEEDDataRecord, METH_O, NULL}, + { "MSEEDDataRecord_swigregister", MSEEDDataRecord_swigregister, METH_O, NULL}, + { "new_Plugin", _wrap_new_Plugin, METH_VARARGS, NULL}, + { "delete_Plugin", _wrap_delete_Plugin, METH_O, NULL}, + { "Plugin_close", _wrap_Plugin_close, METH_O, NULL}, + { "Plugin_quit", _wrap_Plugin_quit, METH_O, NULL}, + { "Plugin_enableLogging", _wrap_Plugin_enableLogging, METH_O, NULL}, + { "Plugin_setBackfillingBufferSize", _wrap_Plugin_setBackfillingBufferSize, METH_VARARGS, NULL}, + { "Plugin_backfillingBufferSize", _wrap_Plugin_backfillingBufferSize, METH_O, NULL}, + { "Plugin_isExitRequested", _wrap_Plugin_isExitRequested, METH_O, NULL}, + { "Plugin_stats", _wrap_Plugin_stats, METH_O, NULL}, + { "Plugin_resetMaxBytesBuffered", _wrap_Plugin_resetMaxBytesBuffered, METH_O, NULL}, + { "Plugin_setEncoderFactory", _wrap_Plugin_setEncoderFactory, METH_VARARGS, NULL}, + { "Plugin_setAddress", _wrap_Plugin_setAddress, METH_VARARGS, NULL}, + { "Plugin_setHost", _wrap_Plugin_setHost, METH_VARARGS, NULL}, + { "Plugin_host", _wrap_Plugin_host, METH_O, NULL}, + { "Plugin_setPort", _wrap_Plugin_setPort, METH_VARARGS, NULL}, + { "Plugin_port", _wrap_Plugin_port, METH_O, NULL}, + { "Plugin_setBufferSize", _wrap_Plugin_setBufferSize, METH_VARARGS, NULL}, + { "Plugin_bufferSize", _wrap_Plugin_bufferSize, METH_O, NULL}, + { "Plugin_setSSLEnabled", _wrap_Plugin_setSSLEnabled, METH_VARARGS, NULL}, + { "Plugin_setCredentials", _wrap_Plugin_setCredentials, METH_VARARGS, NULL}, + { "Plugin_setMaxFutureEndTime", _wrap_Plugin_setMaxFutureEndTime, METH_VARARGS, NULL}, + { "Plugin_setPacketAckFunc", _wrap_Plugin_setPacketAckFunc, METH_VARARGS, NULL}, + { "Plugin_setSendTimeout", _wrap_Plugin_setSendTimeout, METH_VARARGS, NULL}, + { "Plugin_setTimeouts", _wrap_Plugin_setTimeouts, METH_VARARGS, NULL}, + { "Plugin_readJournal", _wrap_Plugin_readJournal, METH_O, NULL}, + { "Plugin_setJournal", _wrap_Plugin_setJournal, METH_VARARGS, NULL}, + { "Plugin_setFlushInterval", _wrap_Plugin_setFlushInterval, METH_VARARGS, NULL}, + { "Plugin_streamStates", _wrap_Plugin_streamStates, METH_O, NULL}, + { "Plugin_writeJournal", _wrap_Plugin_writeJournal, METH_VARARGS, NULL}, + { "Plugin_flushEncoders", _wrap_Plugin_flushEncoders, METH_O, NULL}, + { "Plugin_dumpPackets", _wrap_Plugin_dumpPackets, METH_VARARGS, NULL}, + { "Plugin_packetBuffer", _wrap_Plugin_packetBuffer, METH_O, NULL}, + { "Plugin_setAgent", _wrap_Plugin_setAgent, METH_VARARGS, NULL}, + { "Plugin_version", _wrap_Plugin_version, METH_O, NULL}, + { "Plugin_push", _wrap_Plugin_push, METH_VARARGS, NULL}, + { "Plugin_swigregister", Plugin_swigregister, METH_O, NULL}, + { "Plugin_swiginit", Plugin_swiginit, METH_VARARGS, NULL}, + { "RawResponseHeader_timeSeconds_set", _wrap_RawResponseHeader_timeSeconds_set, METH_VARARGS, NULL}, + { "RawResponseHeader_timeSeconds_get", _wrap_RawResponseHeader_timeSeconds_get, METH_O, NULL}, + { "RawResponseHeader_timeMicroSeconds_set", _wrap_RawResponseHeader_timeMicroSeconds_set, METH_VARARGS, NULL}, + { "RawResponseHeader_timeMicroSeconds_get", _wrap_RawResponseHeader_timeMicroSeconds_get, METH_O, NULL}, + { "RawResponseHeader_get", _wrap_RawResponseHeader_get, METH_VARARGS, NULL}, + { "RawResponseHeader_dataSize", _wrap_RawResponseHeader_dataSize, METH_O, NULL}, + { "new_RawResponseHeader", _wrap_new_RawResponseHeader, METH_NOARGS, NULL}, + { "delete_RawResponseHeader", _wrap_delete_RawResponseHeader, METH_O, NULL}, + { "RawResponseHeader_swigregister", RawResponseHeader_swigregister, METH_O, NULL}, + { "RawResponseHeader_swiginit", RawResponseHeader_swiginit, METH_VARARGS, NULL}, + { "RawDataRecord_formatName", _wrap_RawDataRecord_formatName, METH_O, NULL}, + { "RawDataRecord_readMetaData", _wrap_RawDataRecord_readMetaData, METH_VARARGS, NULL}, + { "RawDataRecord_setHeader", _wrap_RawDataRecord_setHeader, METH_VARARGS, NULL}, + { "RawDataRecord_header", _wrap_RawDataRecord_header, METH_O, NULL}, + { "RawDataRecord_startTime", _wrap_RawDataRecord_startTime, METH_O, NULL}, + { "RawDataRecord_endTime", _wrap_RawDataRecord_endTime, METH_O, NULL}, + { "RawDataRecord_canTrim", _wrap_RawDataRecord_canTrim, METH_O, NULL}, + { "RawDataRecord_canMerge", _wrap_RawDataRecord_canMerge, METH_O, NULL}, + { "RawDataRecord_trim", _wrap_RawDataRecord_trim, METH_VARARGS, NULL}, + { "RawDataRecord_dataSize", _wrap_RawDataRecord_dataSize, METH_VARARGS, NULL}, + { "RawDataRecord_get", _wrap_RawDataRecord_get, METH_VARARGS, NULL}, + { "RawDataRecord_getData", _wrap_RawDataRecord_getData, METH_VARARGS, NULL}, + { "RawDataRecord_put", _wrap_RawDataRecord_put, METH_VARARGS, NULL}, + { "RawDataRecord_packetType", _wrap_RawDataRecord_packetType, METH_O, NULL}, + { "RawDataRecord_setStartTime", _wrap_RawDataRecord_setStartTime, METH_VARARGS, NULL}, + { "RawDataRecord_setSamplingFrequency", _wrap_RawDataRecord_setSamplingFrequency, METH_VARARGS, NULL}, + { "RawDataRecord_setDataType", _wrap_RawDataRecord_setDataType, METH_VARARGS, NULL}, + { "RawDataRecord_setBuffer", _wrap_RawDataRecord_setBuffer, METH_VARARGS, NULL}, + { "delete_RawDataRecord", _wrap_delete_RawDataRecord, METH_O, NULL}, + { "RawDataRecord_swigregister", RawDataRecord_swigregister, METH_O, NULL}, + { "FixedRawDataRecord_canTrim", _wrap_FixedRawDataRecord_canTrim, METH_O, NULL}, + { "FixedRawDataRecord_canMerge", _wrap_FixedRawDataRecord_canMerge, METH_O, NULL}, + { "FixedRawDataRecord_trim", _wrap_FixedRawDataRecord_trim, METH_VARARGS, NULL}, + { "FixedRawDataRecord_formatName", _wrap_FixedRawDataRecord_formatName, METH_O, NULL}, + { "FixedRawDataRecord_get", _wrap_FixedRawDataRecord_get, METH_VARARGS, NULL}, + { "FixedRawDataRecord_packetType", _wrap_FixedRawDataRecord_packetType, METH_O, NULL}, + { "delete_FixedRawDataRecord", _wrap_delete_FixedRawDataRecord, METH_O, NULL}, + { "FixedRawDataRecord_swigregister", FixedRawDataRecord_swigregister, METH_O, NULL}, + { "ChunkHeader_chunkSize_set", _wrap_ChunkHeader_chunkSize_set, METH_VARARGS, NULL}, + { "ChunkHeader_chunkSize_get", _wrap_ChunkHeader_chunkSize_get, METH_O, NULL}, + { "ChunkHeader_setChunkType", _wrap_ChunkHeader_setChunkType, METH_VARARGS, NULL}, + { "ChunkHeader_isChunkType", _wrap_ChunkHeader_isChunkType, METH_VARARGS, NULL}, + { "ChunkHeader_validChunkType", _wrap_ChunkHeader_validChunkType, METH_O, NULL}, + { "ChunkHeader_dataSize", _wrap_ChunkHeader_dataSize, METH_O, NULL}, + { "ChunkHeader_read", _wrap_ChunkHeader_read, METH_VARARGS, NULL}, + { "ChunkHeader_write", _wrap_ChunkHeader_write, METH_VARARGS, NULL}, + { "ChunkHeader_get", _wrap_ChunkHeader_get, METH_VARARGS, NULL}, + { "ChunkHeader_put", _wrap_ChunkHeader_put, METH_VARARGS, NULL}, + { "new_ChunkHeader", _wrap_new_ChunkHeader, METH_NOARGS, NULL}, + { "delete_ChunkHeader", _wrap_delete_ChunkHeader, METH_O, NULL}, + { "ChunkHeader_swigregister", ChunkHeader_swigregister, METH_O, NULL}, + { "ChunkHeader_swiginit", ChunkHeader_swiginit, METH_VARARGS, NULL}, + { "new_ChunkIterator", _wrap_new_ChunkIterator, METH_VARARGS, NULL}, + { "ChunkIterator_begin", _wrap_ChunkIterator_begin, METH_VARARGS, NULL}, + { "ChunkIterator_next", _wrap_ChunkIterator_next, METH_O, NULL}, + { "ChunkIterator_header", _wrap_ChunkIterator_header, METH_O, NULL}, + { "ChunkIterator_headerPos", _wrap_ChunkIterator_headerPos, METH_O, NULL}, + { "ChunkIterator_contentPos", _wrap_ChunkIterator_contentPos, METH_O, NULL}, + { "ChunkIterator_istream", _wrap_ChunkIterator_istream, METH_O, NULL}, + { "delete_ChunkIterator", _wrap_delete_ChunkIterator, METH_O, NULL}, + { "ChunkIterator_swigregister", ChunkIterator_swigregister, METH_O, NULL}, + { "ChunkIterator_swiginit", ChunkIterator_swiginit, METH_VARARGS, NULL}, + { "delete_Chunk", _wrap_delete_Chunk, METH_O, NULL}, + { "Chunk_read", _wrap_Chunk_read, METH_VARARGS, NULL}, + { "Chunk_write", _wrap_Chunk_write, METH_VARARGS, NULL}, + { "Chunk_get", _wrap_Chunk_get, METH_VARARGS, NULL}, + { "Chunk_put", _wrap_Chunk_put, METH_VARARGS, NULL}, + { "Chunk_chunkSize", _wrap_Chunk_chunkSize, METH_O, NULL}, + { "Chunk_swigregister", Chunk_swigregister, METH_O, NULL}, + { "HeadChunk_data_set", _wrap_HeadChunk_data_set, METH_VARARGS, NULL}, + { "HeadChunk_data_get", _wrap_HeadChunk_data_get, METH_O, NULL}, + { "HeadChunk_chunkSize", _wrap_HeadChunk_chunkSize, METH_O, NULL}, + { "HeadChunk_get", _wrap_HeadChunk_get, METH_VARARGS, NULL}, + { "HeadChunk_put", _wrap_HeadChunk_put, METH_VARARGS, NULL}, + { "new_HeadChunk", _wrap_new_HeadChunk, METH_NOARGS, NULL}, + { "delete_HeadChunk", _wrap_delete_HeadChunk, METH_O, NULL}, + { "HeadChunk_swigregister", HeadChunk_swigregister, METH_O, NULL}, + { "HeadChunk_swiginit", HeadChunk_swiginit, METH_VARARGS, NULL}, + { "SID_networkCode_set", _wrap_SID_networkCode_set, METH_VARARGS, NULL}, + { "SID_networkCode_get", _wrap_SID_networkCode_get, METH_O, NULL}, + { "SID_stationCode_set", _wrap_SID_stationCode_set, METH_VARARGS, NULL}, + { "SID_stationCode_get", _wrap_SID_stationCode_get, METH_O, NULL}, + { "SID_locationCode_set", _wrap_SID_locationCode_set, METH_VARARGS, NULL}, + { "SID_locationCode_get", _wrap_SID_locationCode_get, METH_O, NULL}, + { "SID_channelCode_set", _wrap_SID_channelCode_set, METH_VARARGS, NULL}, + { "SID_channelCode_get", _wrap_SID_channelCode_get, METH_O, NULL}, + { "SID___eq__", _wrap_SID___eq__, METH_VARARGS, NULL}, + { "SID___ne__", _wrap_SID___ne__, METH_VARARGS, NULL}, + { "SID_toString", _wrap_SID_toString, METH_O, NULL}, + { "new_SID", _wrap_new_SID, METH_NOARGS, NULL}, + { "delete_SID", _wrap_delete_SID, METH_O, NULL}, + { "SID_swigregister", SID_swigregister, METH_O, NULL}, + { "SID_swiginit", SID_swiginit, METH_VARARGS, NULL}, + { "SIDChunk_chunkSize", _wrap_SIDChunk_chunkSize, METH_O, NULL}, + { "SIDChunk_get", _wrap_SIDChunk_get, METH_VARARGS, NULL}, + { "SIDChunk_put", _wrap_SIDChunk_put, METH_VARARGS, NULL}, + { "new_SIDChunk", _wrap_new_SIDChunk, METH_NOARGS, NULL}, + { "delete_SIDChunk", _wrap_delete_SIDChunk, METH_O, NULL}, + { "SIDChunk_swigregister", SIDChunk_swigregister, METH_O, NULL}, + { "SIDChunk_swiginit", SIDChunk_swiginit, METH_VARARGS, NULL}, + { "RTCM2DataRecord_formatName", _wrap_RTCM2DataRecord_formatName, METH_O, NULL}, + { "RTCM2DataRecord_setTimeStamp", _wrap_RTCM2DataRecord_setTimeStamp, METH_VARARGS, NULL}, + { "RTCM2DataRecord_setSamplingFrequency", _wrap_RTCM2DataRecord_setSamplingFrequency, METH_VARARGS, NULL}, + { "RTCM2DataRecord_readMetaData", _wrap_RTCM2DataRecord_readMetaData, METH_VARARGS, NULL}, + { "RTCM2DataRecord_header", _wrap_RTCM2DataRecord_header, METH_O, NULL}, + { "RTCM2DataRecord_startTime", _wrap_RTCM2DataRecord_startTime, METH_O, NULL}, + { "RTCM2DataRecord_endTime", _wrap_RTCM2DataRecord_endTime, METH_O, NULL}, + { "RTCM2DataRecord_canTrim", _wrap_RTCM2DataRecord_canTrim, METH_O, NULL}, + { "RTCM2DataRecord_canMerge", _wrap_RTCM2DataRecord_canMerge, METH_O, NULL}, + { "RTCM2DataRecord_trim", _wrap_RTCM2DataRecord_trim, METH_VARARGS, NULL}, + { "RTCM2DataRecord_dataSize", _wrap_RTCM2DataRecord_dataSize, METH_VARARGS, NULL}, + { "RTCM2DataRecord_get", _wrap_RTCM2DataRecord_get, METH_VARARGS, NULL}, + { "RTCM2DataRecord_put", _wrap_RTCM2DataRecord_put, METH_VARARGS, NULL}, + { "RTCM2DataRecord_packetType", _wrap_RTCM2DataRecord_packetType, METH_O, NULL}, + { "delete_RTCM2DataRecord", _wrap_delete_RTCM2DataRecord, METH_O, NULL}, + { "RTCM2DataRecord_swigregister", RTCM2DataRecord_swigregister, METH_O, NULL}, + { "new_Socket", _wrap_new_Socket, METH_NOARGS, NULL}, + { "delete_Socket", _wrap_delete_Socket, METH_O, NULL}, + { "Socket_toString", _wrap_Socket_toString, METH_O, NULL}, + { "Socket_fd", _wrap_Socket_fd, METH_O, NULL}, + { "Socket_isValid", _wrap_Socket_isValid, METH_O, NULL}, + { "Socket_shutdown", _wrap_Socket_shutdown, METH_O, NULL}, + { "Socket_close", _wrap_Socket_close, METH_O, NULL}, + { "Socket_send", _wrap_Socket_send, METH_VARARGS, NULL}, + { "Socket_write", _wrap_Socket_write, METH_VARARGS, NULL}, + { "Socket_read", _wrap_Socket_read, METH_VARARGS, NULL}, + { "Socket_flush", _wrap_Socket_flush, METH_O, NULL}, + { "Socket_setSocketTimeout", _wrap_Socket_setSocketTimeout, METH_VARARGS, NULL}, + { "Socket_setNonBlocking", _wrap_Socket_setNonBlocking, METH_VARARGS, NULL}, + { "Socket_connect", _wrap_Socket_connect, METH_VARARGS, NULL}, + { "Socket_rx", _wrap_Socket_rx, METH_O, NULL}, + { "Socket_tx", _wrap_Socket_tx, METH_O, NULL}, + { "Socket_swigregister", Socket_swigregister, METH_O, NULL}, + { "Socket_swiginit", Socket_swiginit, METH_VARARGS, NULL}, + { "new_SSLSocket", _wrap_new_SSLSocket, METH_VARARGS, NULL}, + { "delete_SSLSocket", _wrap_delete_SSLSocket, METH_O, NULL}, + { "SSLSocket_write", _wrap_SSLSocket_write, METH_VARARGS, NULL}, + { "SSLSocket_read", _wrap_SSLSocket_read, METH_VARARGS, NULL}, + { "SSLSocket_connect", _wrap_SSLSocket_connect, METH_VARARGS, NULL}, + { "SSLSocket_sessionID", _wrap_SSLSocket_sessionID, METH_O, NULL}, + { "SSLSocket_sessionIDLength", _wrap_SSLSocket_sessionIDLength, METH_O, NULL}, + { "SSLSocket_peerCertificate", _wrap_SSLSocket_peerCertificate, METH_O, NULL}, + { "SSLSocket_swigregister", SSLSocket_swigregister, METH_O, NULL}, + { "SSLSocket_swiginit", SSLSocket_swiginit, METH_VARARGS, NULL}, + { "new_charArray", _wrap_new_charArray, METH_O, NULL}, + { "delete_charArray", _wrap_delete_charArray, METH_O, NULL}, + { "charArray___getitem__", _wrap_charArray___getitem__, METH_VARARGS, NULL}, + { "charArray___setitem__", _wrap_charArray___setitem__, METH_VARARGS, NULL}, + { "charArray_cast", _wrap_charArray_cast, METH_O, NULL}, + { "charArray_frompointer", _wrap_charArray_frompointer, METH_O, NULL}, + { "charArray_swigregister", charArray_swigregister, METH_O, NULL}, + { "charArray_swiginit", charArray_swiginit, METH_VARARGS, NULL}, + { "new_arraybuf", _wrap_new_arraybuf, METH_VARARGS, NULL}, + { "arraybuf_reset", _wrap_arraybuf_reset, METH_VARARGS, NULL}, + { "arraybuf_seekoff", _wrap_arraybuf_seekoff, METH_VARARGS, NULL}, + { "arraybuf_seekpos", _wrap_arraybuf_seekpos, METH_VARARGS, NULL}, + { "arraybuf_xsgetn", _wrap_arraybuf_xsgetn, METH_VARARGS, NULL}, + { "arraybuf_tellg", _wrap_arraybuf_tellg, METH_O, NULL}, + { "arraybuf_tellp", _wrap_arraybuf_tellp, METH_O, NULL}, + { "delete_arraybuf", _wrap_delete_arraybuf, METH_O, NULL}, + { "arraybuf_swigregister", arraybuf_swigregister, METH_O, NULL}, + { "arraybuf_swiginit", arraybuf_swiginit, METH_VARARGS, NULL}, + { "splitAddress", _wrap_splitAddress, METH_VARARGS, NULL}, + { "tokenize", _wrap_tokenize, METH_VARARGS, NULL}, + { "trim", _wrap_trim, METH_VARARGS, NULL}, + { "timeToTimestamp", _wrap_timeToTimestamp, METH_VARARGS, NULL}, + { "str2int", _wrap_str2int, METH_VARARGS, NULL}, + { "timestampToTime", _wrap_timestampToTime, METH_O, NULL}, + { "samplesToTimeSpan", _wrap_samplesToTimeSpan, METH_VARARGS, NULL}, + { "timeSpanToSamples", _wrap_timeSpanToSamples, METH_VARARGS, NULL}, + { "timeSpanToSamplesCeil", _wrap_timeSpanToSamplesCeil, METH_VARARGS, NULL}, + { "timeSpanToSamplesFloor", _wrap_timeSpanToSamplesFloor, METH_VARARGS, NULL}, + { "dataTypeSize", _wrap_dataTypeSize, METH_O, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { { NULL, NULL, 0, NULL } }; @@ -24963,13 +24516,13 @@ static swig_type_info _swigt__p_Gempa__CAPS__Socket__Device__Status = {"_p_Gempa static swig_type_info _swigt__p_Gempa__CAPS__Steim1EncoderFactory = {"_p_Gempa__CAPS__Steim1EncoderFactory", "Gempa::CAPS::Steim1EncoderFactory *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__Steim2EncoderFactory = {"_p_Gempa__CAPS__Steim2EncoderFactory", "Gempa::CAPS::Steim2EncoderFactory *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__SteimEncoderFactory = {"_p_Gempa__CAPS__SteimEncoderFactory", "Gempa::CAPS::SteimEncoderFactory *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_Gempa__CAPS__Time = {"_p_Gempa__CAPS__Time", "Gempa::CAPS::Time *|Gempa::CAPS::SPClock::INT_TIME *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Gempa__CAPS__Time = {"_p_Gempa__CAPS__Time", "Gempa::CAPS::Time *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__TimeSpan = {"_p_Gempa__CAPS__TimeSpan", "Gempa::CAPS::TimeSpan *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__TimeStamp = {"_p_Gempa__CAPS__TimeStamp", "Gempa::CAPS::TimeStamp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__UOM = {"_p_Gempa__CAPS__UOM", "Gempa::CAPS::UOM *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Gempa__CAPS__arraybuf = {"_p_Gempa__CAPS__arraybuf", "Gempa::CAPS::arraybuf *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_INT_TIME = {"_p_INT_TIME", "INT_TIME *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PacketAckFunc = {"_p_PacketAckFunc", "PacketAckFunc *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PacketBuffer = {"_p_PacketBuffer", "PacketBuffer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_SSL_CTX = {"_p_SSL_CTX", "SSL_CTX *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_StreamStates = {"_p_StreamStates", "StreamStates *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_X509 = {"_p_X509", "X509 *", 0, 0, (void*)0, 0}; @@ -24991,6 +24544,7 @@ static swig_type_info _swigt__p_p_f_p_q_const__char_v_______void = {"_p_p_f_p_q_ static swig_type_info _swigt__p_pos_type = {"_p_pos_type", "pos_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t = {"_p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t", "std::deque< boost::shared_ptr< Gempa::CAPS::Packet > > *|Gempa::CAPS::Plugin::PacketBuffer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__ios_base__openmode = {"_p_std__ios_base__openmode", "std::ios_base::openmode *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__ios_base__seekdir = {"_p_std__ios_base__seekdir", "std::ios_base::seekdir *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; @@ -25004,7 +24558,6 @@ static swig_type_info _swigt__p_std__streamsize = {"_p_std__streamsize", "std::s static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_char_t = {"_p_std__vectorT_char_t", "std::vector< char > *|Buffer *|Gempa::CAPS::DataRecord::Buffer *|Gempa::CAPS::AnyDataRecord::Buffer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_timeval = {"_p_timeval", "timeval *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_uint = {"_p_uint", "uint *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0}; @@ -25055,8 +24608,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_Gempa__CAPS__TimeStamp, &_swigt__p_Gempa__CAPS__UOM, &_swigt__p_Gempa__CAPS__arraybuf, - &_swigt__p_INT_TIME, &_swigt__p_PacketAckFunc, + &_swigt__p_PacketBuffer, &_swigt__p_SSL_CTX, &_swigt__p_StreamStates, &_swigt__p_X509, @@ -25078,6 +24631,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_pos_type, &_swigt__p_short, &_swigt__p_signed_char, + &_swigt__p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t, &_swigt__p_std__ios_base__openmode, &_swigt__p_std__ios_base__seekdir, &_swigt__p_std__istream, @@ -25091,7 +24645,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__string, &_swigt__p_std__vectorT_char_t, &_swigt__p_timeval, - &_swigt__p_uint, &_swigt__p_unsigned_char, &_swigt__p_unsigned_int, &_swigt__p_unsigned_long_long, @@ -25142,8 +24695,8 @@ static swig_cast_info _swigc__p_Gempa__CAPS__TimeSpan[] = { {&_swigt__p_Gempa__ static swig_cast_info _swigc__p_Gempa__CAPS__TimeStamp[] = { {&_swigt__p_Gempa__CAPS__TimeStamp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Gempa__CAPS__UOM[] = { {&_swigt__p_Gempa__CAPS__UOM, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Gempa__CAPS__arraybuf[] = { {&_swigt__p_Gempa__CAPS__arraybuf, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_INT_TIME[] = { {&_swigt__p_INT_TIME, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PacketAckFunc[] = { {&_swigt__p_PacketAckFunc, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PacketBuffer[] = { {&_swigt__p_PacketBuffer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_SSL_CTX[] = { {&_swigt__p_SSL_CTX, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_StreamStates[] = { {&_swigt__p_StreamStates, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_X509[] = { {&_swigt__p_X509, 0, 0, 0},{0, 0, 0, 0}}; @@ -25165,6 +24718,7 @@ static swig_cast_info _swigc__p_p_f_p_q_const__char_v_______void[] = { {&_swigt static swig_cast_info _swigc__p_pos_type[] = { {&_swigt__p_pos_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t[] = { {&_swigt__p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__ios_base__openmode[] = { {&_swigt__p_std__ios_base__openmode, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__ios_base__seekdir[] = { {&_swigt__p_std__ios_base__seekdir, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; @@ -25178,7 +24732,6 @@ static swig_cast_info _swigc__p_std__streamsize[] = { {&_swigt__p_std__streamsi static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_char_t[] = { {&_swigt__p_std__vectorT_char_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_timeval[] = { {&_swigt__p_timeval, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_uint[] = { {&_swigt__p_uint, 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 _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; @@ -25229,8 +24782,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_Gempa__CAPS__TimeStamp, _swigc__p_Gempa__CAPS__UOM, _swigc__p_Gempa__CAPS__arraybuf, - _swigc__p_INT_TIME, _swigc__p_PacketAckFunc, + _swigc__p_PacketBuffer, _swigc__p_SSL_CTX, _swigc__p_StreamStates, _swigc__p_X509, @@ -25252,6 +24805,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_pos_type, _swigc__p_short, _swigc__p_signed_char, + _swigc__p_std__dequeT_boost__shared_ptrT_Gempa__CAPS__Packet_t_t, _swigc__p_std__ios_base__openmode, _swigc__p_std__ios_base__seekdir, _swigc__p_std__istream, @@ -25265,7 +24819,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__string, _swigc__p_std__vectorT_char_t, _swigc__p_timeval, - _swigc__p_uint, _swigc__p_unsigned_char, _swigc__p_unsigned_int, _swigc__p_unsigned_long_long, @@ -25381,7 +24934,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; @@ -25389,7 +24942,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 */ @@ -25464,7 +25017,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++; @@ -25586,17 +25139,6 @@ extern "C" { return str; } - SWIGINTERN int - swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { - char *tmp; - PyObject *str = swig_varlink_str(v); - fprintf(fp,"Swig global variables "); - fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str)); - SWIG_Python_str_DelForPy3(tmp); - Py_DECREF(str); - return 0; - } - SWIGINTERN void swig_varlink_dealloc(swig_varlinkobject *v) { swig_globalvar *var = v->vars; @@ -25655,11 +25197,11 @@ extern "C" { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ #endif - (char *)"swigvarlink", /* tp_name */ + "swigvarlink", /* tp_name */ sizeof(swig_varlinkobject), /* tp_basicsize */ 0, /* tp_itemsize */ (destructor) swig_varlink_dealloc, /* tp_dealloc */ - (printfunc) swig_varlink_print, /* tp_print */ + 0, /* tp_print */ (getattrfunc) swig_varlink_getattr, /* tp_getattr */ (setattrfunc) swig_varlink_setattr, /* tp_setattr */ 0, /* tp_compare */ @@ -25679,36 +25221,30 @@ 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 */ -#endif -#if PY_VERSION_HEX >= 0x02060000 0, /* tp_version_tag */ -#endif #if PY_VERSION_HEX >= 0x03040000 0, /* tp_finalize */ #endif +#if PY_VERSION_HEX >= 0x03080000 + 0, /* tp_vectorcall */ +#endif +#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000) + 0, /* tp_print */ +#endif #ifdef COUNT_ALLOCS 0, /* tp_allocs */ 0, /* tp_frees */ 0, /* tp_maxalloc */ -#if PY_VERSION_HEX >= 0x02050000 0, /* tp_prev */ -#endif 0 /* tp_next */ #endif }; varlink_type = tmp; type_init = 1; -#if PY_VERSION_HEX < 0x02020000 - varlink_type.ob_type = &PyType_Type; -#else if (PyType_Ready(&varlink_type) < 0) return NULL; -#endif } return &varlink_type; } @@ -25724,14 +25260,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; @@ -25742,9 +25278,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; } /* ----------------------------------------------------------------------------- @@ -25810,9 +25348,9 @@ extern "C" { char *ndoc = (char*)malloc(ldoc + lptr + 10); if (ndoc) { char *buff = ndoc; - strncpy(buff, methods[i].ml_doc, ldoc); + 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; @@ -25823,6 +25361,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 @@ -25842,20 +25438,12 @@ PyObject* void #endif SWIG_init(void) { - PyObject *m, *d, *md; + PyObject *m, *d, *md, *globals; + #if PY_VERSION_HEX >= 0x03000000 static struct PyModuleDef SWIG_module = { -# if PY_VERSION_HEX >= 0x03020000 PyModuleDef_HEAD_INIT, -# else - { - PyObject_HEAD_INIT(NULL) - NULL, /* m_init */ - 0, /* m_index */ - NULL, /* m_copy */ - }, -# endif - (char *) SWIG_name, + SWIG_name, NULL, -1, SwigMethods, @@ -25874,8 +25462,8 @@ SWIG_init(void) { (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL }; static SwigPyGetSet thisown_getset_closure = { - (PyCFunction) SwigPyObject_own, - (PyCFunction) SwigPyObject_own + SwigPyObject_own, + SwigPyObject_own }; static PyGetSetDef thisown_getset_def = { (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure @@ -25906,13 +25494,23 @@ SWIG_init(void) { 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); #if PY_VERSION_HEX >= 0x03000000 m = PyModule_Create(&SWIG_module); #else - m = Py_InitModule((char *) SWIG_name, SwigMethods); + m = Py_InitModule(SWIG_name, SwigMethods); #endif md = d = PyModule_GetDict(m); @@ -25963,8 +25561,18 @@ SWIG_init(void) { import_array(); - PyDict_SetItemString(md,(char *)"cvar", SWIG_globals()); - SWIG_addvarlink(SWIG_globals(),(char *)"Time_Null",Swig_var_Time_Null_get, Swig_var_Time_Null_set); + globals = SWIG_globals(); + if (!globals) { + PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals."); +#if PY_VERSION_HEX >= 0x03000000 + return NULL; +#else + return; +#endif + } + PyDict_SetItemString(md, "cvar", globals); + Py_DECREF(globals); + SWIG_addvarlink(globals, "Time_Null", Swig_var_Time_Null_get, Swig_var_Time_Null_set); SWIG_Python_SetConstant(d, "UnknownPacket",SWIG_From_int(static_cast< int >(Gempa::CAPS::UnknownPacket))); SWIG_Python_SetConstant(d, "RawDataPacket",SWIG_From_int(static_cast< int >(Gempa::CAPS::RawDataPacket))); SWIG_Python_SetConstant(d, "MSEEDPacket",SWIG_From_int(static_cast< int >(Gempa::CAPS::MSEEDPacket))); @@ -25998,14 +25606,14 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "LL_INFO",SWIG_From_int(static_cast< int >(Gempa::CAPS::LL_INFO))); SWIG_Python_SetConstant(d, "LL_DEBUG",SWIG_From_int(static_cast< int >(Gempa::CAPS::LL_DEBUG))); SWIG_Python_SetConstant(d, "LL_QUANTITY",SWIG_From_int(static_cast< int >(Gempa::CAPS::LL_QUANTITY))); - SWIG_addvarlink(SWIG_globals(),(char *)"LogHandler",Swig_var_LogHandler_get, Swig_var_LogHandler_set); + SWIG_addvarlink(globals, "LogHandler", Swig_var_LogHandler_get, Swig_var_LogHandler_set); SWIG_Python_SetConstant(d, "Plugin_Success",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::Success))); SWIG_Python_SetConstant(d, "Plugin_PacketSize",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::PacketSize))); SWIG_Python_SetConstant(d, "Plugin_PacketLoss",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::PacketLoss))); SWIG_Python_SetConstant(d, "Plugin_PacketNotValid",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::PacketNotValid))); SWIG_Python_SetConstant(d, "Plugin_PacketNotSupported",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::PacketNotSupported))); SWIG_Python_SetConstant(d, "Plugin_MaxFutureEndTimeExceeded",SWIG_From_int(static_cast< int >(Gempa::CAPS::Plugin::MaxFutureEndTimeExceeded))); - SWIG_addvarlink(SWIG_globals(),(char *)"ChunkHeaderSize",Swig_var_ChunkHeaderSize_get, Swig_var_ChunkHeaderSize_set); + SWIG_addvarlink(globals, "ChunkHeaderSize", Swig_var_ChunkHeaderSize_get, Swig_var_ChunkHeaderSize_set); SWIG_Python_SetConstant(d, "Socket_Success",SWIG_From_int(static_cast< int >(Gempa::CAPS::Socket::Success))); SWIG_Python_SetConstant(d, "Socket_Error",SWIG_From_int(static_cast< int >(Gempa::CAPS::Socket::Error))); SWIG_Python_SetConstant(d, "Socket_AllocationError",SWIG_From_int(static_cast< int >(Gempa::CAPS::Socket::AllocationError)));