class Cqpid::Address

Public Class Methods

new(*args) click to toggle source
SWIGINTERN VALUE _wrap_new_Address(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Address__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_qpid__messaging__Address, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Address__SWIG_4(nargs, args, self);
    }
  }
  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_Address__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_HASH) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_Address__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_HASH) ? 1 : 0;
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Address__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Address.new", 
    "    Address.new()\n"
    "    Address.new(std::string const &address)\n"
    "    Address.new(std::string const &name, std::string const &subject, qpid::types::Variant::Map const &options, std::string const &type)\n"
    "    Address.new(std::string const &name, std::string const &subject, qpid::types::Variant::Map const &options)\n"
    "    Address.new(qpid::messaging::Address const &address)\n");
  
  return Qnil;
}

Public Instance Methods

getName(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_getName(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      result = (std::string *) &((qpid::messaging::Address const *)arg1)->getName();
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}
getOptions(*args) click to toggle source
SWIGINTERN VALUE _wrap_Address_getOptions(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_qpid__messaging__Address, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Address_getOptions__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_qpid__messaging__Address, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Address_getOptions__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Address.getOptions", 
    "    qpid::types::Variant::Map & Address.getOptions()\n"
    "    qpid::types::Variant::Map & Address.getOptions()\n");
  
  return Qnil;
}
getSubject(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_getSubject(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address const *","getSubject", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      result = (std::string *) &((qpid::messaging::Address const *)arg1)->getSubject();
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}
getType(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_getType(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string 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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      result = ((qpid::messaging::Address const *)arg1)->getType();
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}
setName(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_setName(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      (arg1)->setName((std::string const &)*arg2);
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}
setOptions(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_setOptions(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  qpid::types::Variant::Map *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address *","setOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    arg2 = new qpid::types::Variant::Map();
    RbToMap(argv[0], arg2);
  }
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      (arg1)->setOptions((qpid::types::Variant::Map const &)*arg2);
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  {
    delete arg2;
  }
  return Qnil;
fail:
  {
    delete arg2;
  }
  return Qnil;
}
setSubject(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_setSubject(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address *","setSubject", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setSubject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setSubject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      (arg1)->setSubject((std::string const &)*arg2);
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}
setType(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_setType(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      (arg1)->setType((std::string const &)*arg2);
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}
str(*args) click to toggle source
SWIGINTERN VALUE
_wrap_Address_str(int argc, VALUE *argv, VALUE self) {
  qpid::messaging::Address *arg1 = (qpid::messaging::Address *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string 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_qpid__messaging__Address, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::Address const *","str", 1, self )); 
  }
  arg1 = reinterpret_cast< qpid::messaging::Address * >(argp1);
  {
    static VALUE eMessagingError = rb_define_class("MessagingError",
      rb_eStandardError);
    
    try {
      result = ((qpid::messaging::Address const *)arg1)->str();
    }
    catch(qpid::messaging::ConnectionError& error) {
      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransportFailure& error) {
      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionAborted& error) {
      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionUnknown& error) {
      static VALUE merror = rb_define_class("TransactionUnknown", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TransactionError& error) {
      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::UnauthorizedAccess& error) {
      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SessionError& error) {
      static VALUE merror = rb_define_class("SessionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::TargetCapacityExceeded& error) {
      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SendError& error) {
      static VALUE merror = rb_define_class("SendError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::SenderError& error) {
      static VALUE merror = rb_define_class("SenderError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NoMessageAvailable& error) {
      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::FetchError& error) {
      static VALUE merror = rb_define_class("FetchError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ReceiverError& error) {
      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::InvalidOptionString& error) {
      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::KeyError& error) {
      static VALUE merror = rb_define_class("KeyError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AssertionFailed& error) {
      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::NotFound& error) {
      static VALUE merror = rb_define_class("NotFound", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::ResolutionError& error) {
      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MalformedAddress& error) {
      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::AddressError& error) {
      static VALUE merror = rb_define_class("AddressError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::LinkError& error) {
      static VALUE merror = rb_define_class("LinkError", eMessagingError);
      rb_raise(merror, "%s", error.what());
    }
    catch(qpid::messaging::MessagingException& error) {
      rb_raise(eMessagingError, "%s", error.what());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}