Class: Quickfix::PostgreSQLStore

Inherits:
((swig_class *) SWIGTYPE_p_FIX__MessageStore->clientdata)->klass
  • Object
show all
Defined in:
ext/quickfix/QuickfixRuby.cpp

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



120084
120085
120086
120087
120088
120089
120090
120091
120092
120093
120094
120095
120096
120097
120098
120099
120100
120101
120102
120103
120104
120105
120106
120107
120108
120109
120110
120111
120112
120113
120114
120115
120116
120117
120118
120119
120120
120121
120122
120123
120124
120125
120126
120127
120128
120129
120130
120131
120132
120133
120134
120135
120136
120137
120138
120139
120140
120141
120142
120143
120144
120145
120146
120147
120148
120149
120150
120151
120152
120153
120154
120155
120156
120157
120158
120159
120160
120161
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120084

SWIGINTERN VALUE _wrap_new_PostgreSQLStore(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs;
  if (argc > 7) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionID, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FIX__DatabaseConnectionPoolT_FIX__PostgreSQLConnection_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PostgreSQLStore__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FIX__SessionID, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PostgreSQLStore__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "PostgreSQLStore.new", 
    "    PostgreSQLStore.new(FIX::UtcTimeStamp const &now, FIX::SessionID const &sessionID, FIX::DatabaseConnectionID const &connection, FIX::PostgreSQLConnectionPool *pool)\n"
    "    PostgreSQLStore.new(FIX::UtcTimeStamp const &now, FIX::SessionID const &sessionID, std::string const &database, std::string const &user, std::string const &password, std::string const &host, short port)\n");
  
  return Qnil;
}

Instance Method Details

#get(*args) ⇒ Object 



120235
120236
120237
120238
120239
120240
120241
120242
120243
120244
120245
120246
120247
120248
120249
120250
120251
120252
120253
120254
120255
120256
120257
120258
120259
120260
120261
120262
120263
120264
120265
120266
120267
120268
120269
120270
120271
120272
120273
120274
120275
120276
120277
120278
120279
120280
120281
120282
120283
120284
120285
120286
120287
120288
120289
120290
120291
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120235

SWIGINTERN VALUE
_wrap_PostgreSQLStore_get(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  FIX::SEQNUM arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FIX::SEQNUM","get", 2, argv[0] ));
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FIX::SEQNUM","get", 3, argv[1] ));
  } 
  arg3 = static_cast< FIX::SEQNUM >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string,std::allocator< std::string > > &","get", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string,std::allocator< std::string > > &","get", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp4);
  {
    if(tryRubyException([&]() mutable 
        {
      ((FIX::PostgreSQLStore const *)arg1)->get(arg2,arg3,*arg4);
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#getCreationTime(*args) ⇒ Object 



120508
120509
120510
120511
120512
120513
120514
120515
120516
120517
120518
120519
120520
120521
120522
120523
120524
120525
120526
120527
120528
120529
120530
120531
120532
120533
120534
120535
120536
120537
120538
120539
120540
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120508

SWIGINTERN VALUE
_wrap_PostgreSQLStore_getCreationTime(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::UtcTimeStamp result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore const *","getCreationTime", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      result = ((FIX::PostgreSQLStore const *)arg1)->getCreationTime();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  vresult = SWIG_NewPointerObj((new FIX::UtcTimeStamp(result)), SWIGTYPE_p_FIX__UtcTimeStamp, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#getNextSenderMsgSeqNum(*args) ⇒ Object 



120294
120295
120296
120297
120298
120299
120300
120301
120302
120303
120304
120305
120306
120307
120308
120309
120310
120311
120312
120313
120314
120315
120316
120317
120318
120319
120320
120321
120322
120323
120324
120325
120326
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120294

SWIGINTERN VALUE
_wrap_PostgreSQLStore_getNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SEQNUM result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore const *","getNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      result = (FIX::SEQNUM)((FIX::PostgreSQLStore const *)arg1)->getNextSenderMsgSeqNum();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}

#getNextTargetMsgSeqNum(*args) ⇒ Object 



120329
120330
120331
120332
120333
120334
120335
120336
120337
120338
120339
120340
120341
120342
120343
120344
120345
120346
120347
120348
120349
120350
120351
120352
120353
120354
120355
120356
120357
120358
120359
120360
120361
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120329

SWIGINTERN VALUE
_wrap_PostgreSQLStore_getNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::SEQNUM result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore const *","getNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      result = (FIX::SEQNUM)((FIX::PostgreSQLStore const *)arg1)->getNextTargetMsgSeqNum();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}

#incrNextSenderMsgSeqNum(*args) ⇒ Object 



120444
120445
120446
120447
120448
120449
120450
120451
120452
120453
120454
120455
120456
120457
120458
120459
120460
120461
120462
120463
120464
120465
120466
120467
120468
120469
120470
120471
120472
120473
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120444

SWIGINTERN VALUE
_wrap_PostgreSQLStore_incrNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","incrNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->incrNextSenderMsgSeqNum();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#incrNextTargetMsgSeqNum(*args) ⇒ Object 



120476
120477
120478
120479
120480
120481
120482
120483
120484
120485
120486
120487
120488
120489
120490
120491
120492
120493
120494
120495
120496
120497
120498
120499
120500
120501
120502
120503
120504
120505
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120476

SWIGINTERN VALUE
_wrap_PostgreSQLStore_incrNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","incrNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->incrNextTargetMsgSeqNum();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#refresh(*args) ⇒ Object 



120586
120587
120588
120589
120590
120591
120592
120593
120594
120595
120596
120597
120598
120599
120600
120601
120602
120603
120604
120605
120606
120607
120608
120609
120610
120611
120612
120613
120614
120615
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120586

SWIGINTERN VALUE
_wrap_PostgreSQLStore_refresh(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","refresh", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->refresh();
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#reset(*args) ⇒ Object 



120543
120544
120545
120546
120547
120548
120549
120550
120551
120552
120553
120554
120555
120556
120557
120558
120559
120560
120561
120562
120563
120564
120565
120566
120567
120568
120569
120570
120571
120572
120573
120574
120575
120576
120577
120578
120579
120580
120581
120582
120583
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120543

SWIGINTERN VALUE
_wrap_PostgreSQLStore_reset(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::UtcTimeStamp *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__UtcTimeStamp,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::UtcTimeStamp const &","reset", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::UtcTimeStamp const &","reset", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::UtcTimeStamp * >(argp2);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->reset((FIX::UtcTimeStamp const &)*arg2);
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#set(*args) ⇒ Object 



120170
120171
120172
120173
120174
120175
120176
120177
120178
120179
120180
120181
120182
120183
120184
120185
120186
120187
120188
120189
120190
120191
120192
120193
120194
120195
120196
120197
120198
120199
120200
120201
120202
120203
120204
120205
120206
120207
120208
120209
120210
120211
120212
120213
120214
120215
120216
120217
120218
120219
120220
120221
120222
120223
120224
120225
120226
120227
120228
120229
120230
120231
120232
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120170

SWIGINTERN VALUE
_wrap_PostgreSQLStore_set(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","set", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FIX::SEQNUM","set", 2, argv[0] ));
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","set", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","set", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    if(tryRubyException([&]() mutable 
        {
      result = (bool)(arg1)->set(arg2,(std::string const &)*arg3);
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  {
    if( std::string("std::string const &") == "std::string &" ) 	 
    {
      rb_str_resize( argv[1], 0 );
      rb_str_append( argv[1], rb_str_new2(arg3->c_str()) );
    }
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}

#setNextSenderMsgSeqNum(*args) ⇒ Object 



120364
120365
120366
120367
120368
120369
120370
120371
120372
120373
120374
120375
120376
120377
120378
120379
120380
120381
120382
120383
120384
120385
120386
120387
120388
120389
120390
120391
120392
120393
120394
120395
120396
120397
120398
120399
120400
120401
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120364

SWIGINTERN VALUE
_wrap_PostgreSQLStore_setNextSenderMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","setNextSenderMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FIX::SEQNUM","setNextSenderMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->setNextSenderMsgSeqNum(arg2);
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}

#setNextTargetMsgSeqNum(*args) ⇒ Object 



120404
120405
120406
120407
120408
120409
120410
120411
120412
120413
120414
120415
120416
120417
120418
120419
120420
120421
120422
120423
120424
120425
120426
120427
120428
120429
120430
120431
120432
120433
120434
120435
120436
120437
120438
120439
120440
120441
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 120404

SWIGINTERN VALUE
_wrap_PostgreSQLStore_setNextTargetMsgSeqNum(int argc, VALUE *argv, VALUE self) {
  FIX::PostgreSQLStore *arg1 = (FIX::PostgreSQLStore *) 0 ;
  FIX::SEQNUM arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FIX__PostgreSQLStore, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::PostgreSQLStore *","setNextTargetMsgSeqNum", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::PostgreSQLStore * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FIX::SEQNUM","setNextTargetMsgSeqNum", 2, argv[0] ));
  } 
  arg2 = static_cast< FIX::SEQNUM >(val2);
  {
    if(tryRubyException([&]() mutable 
        {
      (arg1)->setNextTargetMsgSeqNum(arg2);
          return self;
        fail:
          return Qnil;
        }) == Qnil) 
    {
      SWIG_fail;
    }
  }
  return Qnil;
fail:
  return Qnil;
}