Class: Quickfix::SynchronizedApplication

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

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



215740
215741
215742
215743
215744
215745
215746
215747
215748
215749
215750
215751
215752
215753
215754
215755
215756
215757
215758
215759
215760
215761
215762
215763
215764
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215740

SWIGINTERN VALUE
_wrap_new_SynchronizedApplication(int argc, VALUE *argv, VALUE self) {
  FIX::Application *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Quickfix::SynchronizedApplication";
  FIX::SynchronizedApplication *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::Application &","SynchronizedApplication", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","SynchronizedApplication", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< FIX::Application * >(argp1);
  result = (FIX::SynchronizedApplication *)new FIX::SynchronizedApplication(*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Instance Method Details

#app(*args) ⇒ Object 



216130
216131
216132
216133
216134
216135
216136
216137
216138
216139
216140
216141
216142
216143
216144
216145
216146
216147
216148
216149
216150
216151
216152
216153
216154
216155
216156
216157
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216130

SWIGINTERN VALUE
_wrap_SynchronizedApplication_app(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  FIX::Application *result = 0 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result = (FIX::Application *) &(arg1)->app();
  director = dynamic_cast<Swig::Director *>(result);
  if (director) {
    vresult = director->swig_get_self();
  } else {
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  }
  return vresult;
fail:
  return Qnil;
}

#fromAdmin(*args) ⇒ Object 



215955
215956
215957
215958
215959
215960
215961
215962
215963
215964
215965
215966
215967
215968
215969
215970
215971
215972
215973
215974
215975
215976
215977
215978
215979
215980
215981
215982
215983
215984
215985
215986
215987
215988
215989
215990
215991
215992
215993
215994
215995
215996
215997
215998
215999
216000
216001
216002
216003
216004
216005
216006
216007
216008
216009
216010
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215955

SWIGINTERN VALUE
_wrap_SynchronizedApplication_fromAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","fromAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->fromAdmin((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::RejectLogon &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__RejectLogon, SWIG_NewPointerObj((new FIX::RejectLogon(static_cast< const FIX::RejectLogon& >(_e))),SWIGTYPE_p_FIX__RejectLogon,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}

#fromApp(*args) ⇒ Object 



216013
216014
216015
216016
216017
216018
216019
216020
216021
216022
216023
216024
216025
216026
216027
216028
216029
216030
216031
216032
216033
216034
216035
216036
216037
216038
216039
216040
216041
216042
216043
216044
216045
216046
216047
216048
216049
216050
216051
216052
216053
216054
216055
216056
216057
216058
216059
216060
216061
216062
216063
216064
216065
216066
216067
216068
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216013

SWIGINTERN VALUE
_wrap_SynchronizedApplication_fromApp(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","fromApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message const &","fromApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message const &","fromApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","fromApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","fromApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->fromApp((FIX::Message const &)*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::FieldNotFound &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__FieldNotFound, SWIG_NewPointerObj((new FIX::FieldNotFound(static_cast< const FIX::FieldNotFound& >(_e))),SWIGTYPE_p_FIX__FieldNotFound,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectDataFormat &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectDataFormat, SWIG_NewPointerObj((new FIX::IncorrectDataFormat(static_cast< const FIX::IncorrectDataFormat& >(_e))),SWIGTYPE_p_FIX__IncorrectDataFormat,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::IncorrectTagValue &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__IncorrectTagValue, SWIG_NewPointerObj((new FIX::IncorrectTagValue(static_cast< const FIX::IncorrectTagValue& >(_e))),SWIGTYPE_p_FIX__IncorrectTagValue,SWIG_POINTER_OWN))); SWIG_fail;
  }
  catch(FIX::UnsupportedMessageType &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__UnsupportedMessageType, SWIG_NewPointerObj((new FIX::UnsupportedMessageType(static_cast< const FIX::UnsupportedMessageType& >(_e))),SWIGTYPE_p_FIX__UnsupportedMessageType,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}

#m_app(*args) ⇒ Object 



216192
216193
216194
216195
216196
216197
216198
216199
216200
216201
216202
216203
216204
216205
216206
216207
216208
216209
216210
216211
216212
216213
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216192

SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_app_get(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FIX::Application *result = 0 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result = (FIX::Application *) &(FIX::Application &) ((arg1)->m_app);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FIX__Application, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#m_app=(*args) ⇒ Object 



216160
216161
216162
216163
216164
216165
216166
216167
216168
216169
216170
216171
216172
216173
216174
216175
216176
216177
216178
216179
216180
216181
216182
216183
216184
216185
216186
216187
216188
216189
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216160

SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_app_set(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Application *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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_app", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Application,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Application &","m_app", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Application &","m_app", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Application * >(argp2);
  if (arg1) (arg1)->m_app = *arg2;
  return Qnil;
fail:
  return Qnil;
}

#m_mutex(*args) ⇒ Object 



216106
216107
216108
216109
216110
216111
216112
216113
216114
216115
216116
216117
216118
216119
216120
216121
216122
216123
216124
216125
216126
216127
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216106

SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_mutex_get(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Mutex 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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_mutex", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  result =  ((arg1)->m_mutex);
  vresult = SWIG_NewPointerObj((new Mutex(static_cast< const Mutex& >(result))), SWIGTYPE_p_Mutex, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#m_mutex=(*args) ⇒ Object 



216071
216072
216073
216074
216075
216076
216077
216078
216079
216080
216081
216082
216083
216084
216085
216086
216087
216088
216089
216090
216091
216092
216093
216094
216095
216096
216097
216098
216099
216100
216101
216102
216103
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 216071

SWIGINTERN VALUE
_wrap_SynchronizedApplication_m_mutex_set(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  Mutex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","m_mutex", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Mutex,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Mutex","m_mutex", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Mutex","m_mutex", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Mutex * >(argp2));
    }
  }
  if (arg1) (arg1)->m_mutex = arg2;
  return Qnil;
fail:
  return Qnil;
}

#onCreate(*args) ⇒ Object 



215767
215768
215769
215770
215771
215772
215773
215774
215775
215776
215777
215778
215779
215780
215781
215782
215783
215784
215785
215786
215787
215788
215789
215790
215791
215792
215793
215794
215795
215796
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215767

SWIGINTERN VALUE
_wrap_SynchronizedApplication_onCreate(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onCreate", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onCreate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onCreate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onCreate((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

#onLogon(*args) ⇒ Object 



215799
215800
215801
215802
215803
215804
215805
215806
215807
215808
215809
215810
215811
215812
215813
215814
215815
215816
215817
215818
215819
215820
215821
215822
215823
215824
215825
215826
215827
215828
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215799

SWIGINTERN VALUE
_wrap_SynchronizedApplication_onLogon(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onLogon", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogon", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogon", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onLogon((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

#onLogout(*args) ⇒ Object 



215831
215832
215833
215834
215835
215836
215837
215838
215839
215840
215841
215842
215843
215844
215845
215846
215847
215848
215849
215850
215851
215852
215853
215854
215855
215856
215857
215858
215859
215860
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215831

SWIGINTERN VALUE
_wrap_SynchronizedApplication_onLogout(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::SessionID *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","onLogout", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::SessionID const &","onLogout", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","onLogout", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::SessionID * >(argp2);
  (arg1)->onLogout((FIX::SessionID const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}

#toAdmin(*args) ⇒ Object 



215863
215864
215865
215866
215867
215868
215869
215870
215871
215872
215873
215874
215875
215876
215877
215878
215879
215880
215881
215882
215883
215884
215885
215886
215887
215888
215889
215890
215891
215892
215893
215894
215895
215896
215897
215898
215899
215900
215901
215902
215903
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215863

SWIGINTERN VALUE
_wrap_SynchronizedApplication_toAdmin(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","toAdmin", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toAdmin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toAdmin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toAdmin", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toAdmin", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  (arg1)->toAdmin(*arg2,(FIX::SessionID const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}

#toApp(*args) ⇒ Object 



215906
215907
215908
215909
215910
215911
215912
215913
215914
215915
215916
215917
215918
215919
215920
215921
215922
215923
215924
215925
215926
215927
215928
215929
215930
215931
215932
215933
215934
215935
215936
215937
215938
215939
215940
215941
215942
215943
215944
215945
215946
215947
215948
215949
215950
215951
215952
 
# File 'ext/quickfix/QuickfixRuby.cpp', line 215906

SWIGINTERN VALUE
_wrap_SynchronizedApplication_toApp(int argc, VALUE *argv, VALUE self) {
  FIX::SynchronizedApplication *arg1 = (FIX::SynchronizedApplication *) 0 ;
  FIX::Message *arg2 = 0 ;
  FIX::SessionID *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  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__SynchronizedApplication, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FIX::SynchronizedApplication *","toApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FIX::SynchronizedApplication * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FIX__Message,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FIX::Message &","toApp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::Message &","toApp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FIX::Message * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FIX__SessionID,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FIX::SessionID const &","toApp", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FIX::SessionID const &","toApp", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FIX::SessionID * >(argp3);
  try {
    (arg1)->toApp(*arg2,(FIX::SessionID const &)*arg3);
  }
  catch(FIX::DoNotSend &_e) {
    rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_FIX__DoNotSend, SWIG_NewPointerObj((new FIX::DoNotSend(static_cast< const FIX::DoNotSend& >(_e))),SWIGTYPE_p_FIX__DoNotSend,SWIG_POINTER_OWN))); SWIG_fail;
  }
  
  return Qnil;
fail:
  return Qnil;
}