Module: Cproton

Defined in:: ext/cproton/cproton.c

Defined Under Namespace

Constant Summary collapse

PROTON_IMPORT_EXPORT_H =

SWIG_From_int((int)(1))

PN_VERSION_MAJOR =

SWIG_From_int((int)(0))

PN_VERSION_MINOR =

SWIG_From_int((int)(23))

PN_VERSION_POINT =

SWIG_From_int((int)(0))

PROTON_TYPES_H =

SWIG_From_int((int)(1))

PN_MILLIS_MAX =

SWIG_From_unsigned_SS_int((unsigned int)((~0U)))

PROTON_OBJECT_H =

SWIG_From_int((int)(1))

PN_REFCOUNT =

SWIG_From_int((int)((0x1)))

PN_REFCOUNT_KEY =

SWIG_From_int((int)((0x2)))

PN_REFCOUNT_VALUE =

SWIG_From_int((int)((0x4)))

PROTON_ERROR_H =

SWIG_From_int((int)(1))

PN_OK =

SWIG_From_int((int)((0)))

PN_EOS =

SWIG_From_int((int)((-1)))

PN_ERR =

SWIG_From_int((int)((-2)))

PN_OVERFLOW =

SWIG_From_int((int)((-3)))

PN_UNDERFLOW =

SWIG_From_int((int)((-4)))

PN_STATE_ERR =

SWIG_From_int((int)((-5)))

PN_ARG_ERR =

SWIG_From_int((int)((-6)))

PN_TIMEOUT =

SWIG_From_int((int)((-7)))

PN_INTR =

SWIG_From_int((int)((-8)))

PN_INPROGRESS =

SWIG_From_int((int)((-9)))

PN_OUT_OF_MEMORY =

SWIG_From_int((int)((-10)))

PN_ABORTED =

SWIG_From_int((int)((-11)))

PROTON_CONDITION_H =

SWIG_From_int((int)(1))

PROTON_CONNECTION_H =

SWIG_From_int((int)(1))

PN_LOCAL_UNINIT =

SWIG_From_int((int)((1)))

PN_LOCAL_ACTIVE =

SWIG_From_int((int)((2)))

PN_LOCAL_CLOSED =

SWIG_From_int((int)((4)))

PN_REMOTE_UNINIT =

SWIG_From_int((int)((8)))

PN_REMOTE_ACTIVE =

SWIG_From_int((int)((16)))

PN_REMOTE_CLOSED =

SWIG_From_int((int)((32)))

PN_LOCAL_MASK =

SWIG_From_int((int)(((1)|(2)|(4))))

PN_REMOTE_MASK =

SWIG_From_int((int)(((8)|(16)|(32))))

PROTON_SESSION_H =

SWIG_From_int((int)(1))

PROTON_LINK_H =

SWIG_From_int((int)(1))

PN_SND_UNSETTLED =

SWIG_From_int((int)(PN_SND_UNSETTLED))

PN_SND_SETTLED =

SWIG_From_int((int)(PN_SND_SETTLED))

PN_SND_MIXED =

SWIG_From_int((int)(PN_SND_MIXED))

PN_RCV_FIRST =

SWIG_From_int((int)(PN_RCV_FIRST))

PN_RCV_SECOND =

SWIG_From_int((int)(PN_RCV_SECOND))

PROTON_TERMINUS_H =

SWIG_From_int((int)(1))

PN_UNSPECIFIED =

SWIG_From_int((int)(PN_UNSPECIFIED))

PN_SOURCE =

SWIG_From_int((int)(PN_SOURCE))

PN_TARGET =

SWIG_From_int((int)(PN_TARGET))

PN_COORDINATOR =

SWIG_From_int((int)(PN_COORDINATOR))

PN_NONDURABLE =

SWIG_From_int((int)(PN_NONDURABLE))

PN_CONFIGURATION =

SWIG_From_int((int)(PN_CONFIGURATION))

PN_DELIVERIES =

SWIG_From_int((int)(PN_DELIVERIES))

PN_EXPIRE_WITH_LINK =

SWIG_From_int((int)(PN_EXPIRE_WITH_LINK))

PN_EXPIRE_WITH_SESSION =

SWIG_From_int((int)(PN_EXPIRE_WITH_SESSION))

PN_EXPIRE_WITH_CONNECTION =

SWIG_From_int((int)(PN_EXPIRE_WITH_CONNECTION))

PN_EXPIRE_NEVER =

SWIG_From_int((int)(PN_EXPIRE_NEVER))

PN_DIST_MODE_UNSPECIFIED =

SWIG_From_int((int)(PN_DIST_MODE_UNSPECIFIED))

PN_DIST_MODE_COPY =

SWIG_From_int((int)(PN_DIST_MODE_COPY))

PN_DIST_MODE_MOVE =

SWIG_From_int((int)(PN_DIST_MODE_MOVE))

PROTON_DELIVERY_H =

SWIG_From_int((int)(1))

PROTON_DISPOSITION_H =

SWIG_From_int((int)(1))

PN_RECEIVED =

SWIG_From_int((int)((0x0000000000000023)))

PN_ACCEPTED =

SWIG_From_int((int)((0x0000000000000024)))

PN_REJECTED =

SWIG_From_int((int)((0x0000000000000025)))

PN_RELEASED =

SWIG_From_int((int)((0x0000000000000026)))

PN_MODIFIED =

SWIG_From_int((int)((0x0000000000000027)))

PROTON_TRANSPORT_H =

SWIG_From_int((int)(1))

PN_TRACE_OFF =

SWIG_From_int((int)((0)))

PN_TRACE_RAW =

SWIG_From_int((int)((1)))

PN_TRACE_FRM =

SWIG_From_int((int)((2)))

PN_TRACE_DRV =

SWIG_From_int((int)((4)))

PN_TRACE_EVT =

SWIG_From_int((int)((8)))

PROTON_EVENT_H =

SWIG_From_int((int)(1))

PN_EVENT_NONE =

SWIG_From_int((int)(PN_EVENT_NONE))

PN_REACTOR_INIT =

SWIG_From_int((int)(PN_REACTOR_INIT))

PN_REACTOR_QUIESCED =

SWIG_From_int((int)(PN_REACTOR_QUIESCED))

PN_REACTOR_FINAL =

SWIG_From_int((int)(PN_REACTOR_FINAL))

PN_TIMER_TASK =

SWIG_From_int((int)(PN_TIMER_TASK))

PN_CONNECTION_INIT =

SWIG_From_int((int)(PN_CONNECTION_INIT))

PN_CONNECTION_BOUND =

SWIG_From_int((int)(PN_CONNECTION_BOUND))

PN_CONNECTION_UNBOUND =

SWIG_From_int((int)(PN_CONNECTION_UNBOUND))

PN_CONNECTION_LOCAL_OPEN =

SWIG_From_int((int)(PN_CONNECTION_LOCAL_OPEN))

PN_CONNECTION_REMOTE_OPEN =

SWIG_From_int((int)(PN_CONNECTION_REMOTE_OPEN))

PN_CONNECTION_LOCAL_CLOSE =

SWIG_From_int((int)(PN_CONNECTION_LOCAL_CLOSE))

PN_CONNECTION_REMOTE_CLOSE =

SWIG_From_int((int)(PN_CONNECTION_REMOTE_CLOSE))

PN_CONNECTION_FINAL =

SWIG_From_int((int)(PN_CONNECTION_FINAL))

PN_SESSION_INIT =

SWIG_From_int((int)(PN_SESSION_INIT))

PN_SESSION_LOCAL_OPEN =

SWIG_From_int((int)(PN_SESSION_LOCAL_OPEN))

PN_SESSION_REMOTE_OPEN =

SWIG_From_int((int)(PN_SESSION_REMOTE_OPEN))

PN_SESSION_LOCAL_CLOSE =

SWIG_From_int((int)(PN_SESSION_LOCAL_CLOSE))

PN_SESSION_REMOTE_CLOSE =

SWIG_From_int((int)(PN_SESSION_REMOTE_CLOSE))

PN_SESSION_FINAL =

SWIG_From_int((int)(PN_SESSION_FINAL))

PN_LINK_INIT =

SWIG_From_int((int)(PN_LINK_INIT))

PN_LINK_LOCAL_OPEN =

SWIG_From_int((int)(PN_LINK_LOCAL_OPEN))

PN_LINK_REMOTE_OPEN =

SWIG_From_int((int)(PN_LINK_REMOTE_OPEN))

PN_LINK_LOCAL_CLOSE =

SWIG_From_int((int)(PN_LINK_LOCAL_CLOSE))

PN_LINK_REMOTE_CLOSE =

SWIG_From_int((int)(PN_LINK_REMOTE_CLOSE))

PN_LINK_LOCAL_DETACH =

SWIG_From_int((int)(PN_LINK_LOCAL_DETACH))

PN_LINK_REMOTE_DETACH =

SWIG_From_int((int)(PN_LINK_REMOTE_DETACH))

PN_LINK_FLOW =

SWIG_From_int((int)(PN_LINK_FLOW))

PN_LINK_FINAL =

SWIG_From_int((int)(PN_LINK_FINAL))

PN_DELIVERY =

SWIG_From_int((int)(PN_DELIVERY))

PN_TRANSPORT =

SWIG_From_int((int)(PN_TRANSPORT))

PN_TRANSPORT_AUTHENTICATED =

SWIG_From_int((int)(PN_TRANSPORT_AUTHENTICATED))

PN_TRANSPORT_ERROR =

SWIG_From_int((int)(PN_TRANSPORT_ERROR))

PN_TRANSPORT_HEAD_CLOSED =

SWIG_From_int((int)(PN_TRANSPORT_HEAD_CLOSED))

PN_TRANSPORT_TAIL_CLOSED =

SWIG_From_int((int)(PN_TRANSPORT_TAIL_CLOSED))

PN_TRANSPORT_CLOSED =

SWIG_From_int((int)(PN_TRANSPORT_CLOSED))

PN_SELECTABLE_INIT =

SWIG_From_int((int)(PN_SELECTABLE_INIT))

PN_SELECTABLE_UPDATED =

SWIG_From_int((int)(PN_SELECTABLE_UPDATED))

PN_SELECTABLE_READABLE =

SWIG_From_int((int)(PN_SELECTABLE_READABLE))

PN_SELECTABLE_WRITABLE =

SWIG_From_int((int)(PN_SELECTABLE_WRITABLE))

PN_SELECTABLE_ERROR =

SWIG_From_int((int)(PN_SELECTABLE_ERROR))

PN_SELECTABLE_EXPIRED =

SWIG_From_int((int)(PN_SELECTABLE_EXPIRED))

PN_SELECTABLE_FINAL =

SWIG_From_int((int)(PN_SELECTABLE_FINAL))

PN_CONNECTION_WAKE =

SWIG_From_int((int)(PN_CONNECTION_WAKE))

PN_LISTENER_ACCEPT =

SWIG_From_int((int)(PN_LISTENER_ACCEPT))

PN_LISTENER_CLOSE =

SWIG_From_int((int)(PN_LISTENER_CLOSE))

PN_PROACTOR_INTERRUPT =

SWIG_From_int((int)(PN_PROACTOR_INTERRUPT))

PN_PROACTOR_TIMEOUT =

SWIG_From_int((int)(PN_PROACTOR_TIMEOUT))

PN_PROACTOR_INACTIVE =

SWIG_From_int((int)(PN_PROACTOR_INACTIVE))

PN_LISTENER_OPEN =

SWIG_From_int((int)(PN_LISTENER_OPEN))

PROTON_MESSAGE_H =

SWIG_From_int((int)(1))

PN_DEFAULT_PRIORITY =

SWIG_From_int((int)((4)))

PROTON_SASL_H =

SWIG_From_int((int)(1))

PN_SASL_NONE =

SWIG_From_int((int)(PN_SASL_NONE))

PN_SASL_OK =

SWIG_From_int((int)(PN_SASL_OK))

PN_SASL_AUTH =

SWIG_From_int((int)(PN_SASL_AUTH))

PN_SASL_SYS =

SWIG_From_int((int)(PN_SASL_SYS))

PN_SASL_PERM =

SWIG_From_int((int)(PN_SASL_PERM))

PN_SASL_TEMP =

SWIG_From_int((int)(PN_SASL_TEMP))

PROTON_MESSENGER_H =

SWIG_From_int((int)(1))

PN_STATUS_UNKNOWN =

SWIG_From_int((int)(PN_STATUS_UNKNOWN))

PN_STATUS_PENDING =

SWIG_From_int((int)(PN_STATUS_PENDING))

PN_STATUS_ACCEPTED =

SWIG_From_int((int)(PN_STATUS_ACCEPTED))

PN_STATUS_REJECTED =

SWIG_From_int((int)(PN_STATUS_REJECTED))

PN_STATUS_RELEASED =

SWIG_From_int((int)(PN_STATUS_RELEASED))

PN_STATUS_MODIFIED =

SWIG_From_int((int)(PN_STATUS_MODIFIED))

PN_STATUS_ABORTED =

SWIG_From_int((int)(PN_STATUS_ABORTED))

PN_STATUS_SETTLED =

SWIG_From_int((int)(PN_STATUS_SETTLED))

PN_CUMULATIVE =

SWIG_From_int((int)((0x1)))

PN_FLAGS_CHECK_ROUTES =

SWIG_From_int((int)((0x1)))

PN_FLAGS_ALLOW_INSECURE_MECHS =

SWIG_From_int((int)((0x2)))

PROTON_SELECTABLE_H =

SWIG_From_int((int)(1))

PN_INVALID_SOCKET =

SWIG_From_int((int)((-1)))

PROTON_SSL_H =

SWIG_From_int((int)(1))

PN_SSL_MODE_CLIENT =

SWIG_From_int((int)(PN_SSL_MODE_CLIENT))

PN_SSL_MODE_SERVER =

SWIG_From_int((int)(PN_SSL_MODE_SERVER))

PN_SSL_RESUME_UNKNOWN =

SWIG_From_int((int)(PN_SSL_RESUME_UNKNOWN))

PN_SSL_RESUME_NEW =

SWIG_From_int((int)(PN_SSL_RESUME_NEW))

PN_SSL_RESUME_REUSED =

SWIG_From_int((int)(PN_SSL_RESUME_REUSED))

PN_SSL_VERIFY_NULL =

SWIG_From_int((int)(PN_SSL_VERIFY_NULL))

PN_SSL_VERIFY_PEER =

SWIG_From_int((int)(PN_SSL_VERIFY_PEER))

PN_SSL_ANONYMOUS_PEER =

SWIG_From_int((int)(PN_SSL_ANONYMOUS_PEER))

PN_SSL_VERIFY_PEER_NAME =

SWIG_From_int((int)(PN_SSL_VERIFY_PEER_NAME))

PN_SSL_CERT_SUBJECT_COUNTRY_NAME =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_COUNTRY_NAME))

PN_SSL_CERT_SUBJECT_STATE_OR_PROVINCE =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_STATE_OR_PROVINCE))

PN_SSL_CERT_SUBJECT_CITY_OR_LOCALITY =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_CITY_OR_LOCALITY))

PN_SSL_CERT_SUBJECT_ORGANIZATION_NAME =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_ORGANIZATION_NAME))

PN_SSL_CERT_SUBJECT_ORGANIZATION_UNIT =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_ORGANIZATION_UNIT))

PN_SSL_CERT_SUBJECT_COMMON_NAME =

SWIG_From_int((int)(PN_SSL_CERT_SUBJECT_COMMON_NAME))

PN_SSL_SHA1 =

SWIG_From_int((int)(PN_SSL_SHA1))

PN_SSL_SHA256 =

SWIG_From_int((int)(PN_SSL_SHA256))

PN_SSL_SHA512 =

SWIG_From_int((int)(PN_SSL_SHA512))

PN_SSL_MD5 =

SWIG_From_int((int)(PN_SSL_MD5))

PROTON_CODEC_H =

SWIG_From_int((int)(1))

PN_NULL =

SWIG_From_int((int)(PN_NULL))

PN_BOOL =

SWIG_From_int((int)(PN_BOOL))

PN_UBYTE =

SWIG_From_int((int)(PN_UBYTE))

PN_BYTE =

SWIG_From_int((int)(PN_BYTE))

PN_USHORT =

SWIG_From_int((int)(PN_USHORT))

PN_SHORT =

SWIG_From_int((int)(PN_SHORT))

PN_UINT =

SWIG_From_int((int)(PN_UINT))

PN_INT =

SWIG_From_int((int)(PN_INT))

PN_CHAR =

SWIG_From_int((int)(PN_CHAR))

PN_ULONG =

SWIG_From_int((int)(PN_ULONG))

PN_LONG =

SWIG_From_int((int)(PN_LONG))

PN_TIMESTAMP =

SWIG_From_int((int)(PN_TIMESTAMP))

PN_FLOAT =

SWIG_From_int((int)(PN_FLOAT))

PN_DOUBLE =

SWIG_From_int((int)(PN_DOUBLE))

PN_DECIMAL32 =

SWIG_From_int((int)(PN_DECIMAL32))

PN_DECIMAL64 =

SWIG_From_int((int)(PN_DECIMAL64))

PN_DECIMAL128 =

SWIG_From_int((int)(PN_DECIMAL128))

PN_UUID =

SWIG_From_int((int)(PN_UUID))

PN_BINARY =

SWIG_From_int((int)(PN_BINARY))

PN_STRING =

SWIG_From_int((int)(PN_STRING))

PN_SYMBOL =

SWIG_From_int((int)(PN_SYMBOL))

PN_DESCRIBED =

SWIG_From_int((int)(PN_DESCRIBED))

PN_ARRAY =

SWIG_From_int((int)(PN_ARRAY))

PN_LIST =

SWIG_From_int((int)(PN_LIST))

PN_MAP =

SWIG_From_int((int)(PN_MAP))

PN_INVALID =

SWIG_From_int((int)(PN_INVALID))

PROTON_CONNECTION_DRIVER_H =

SWIG_From_int((int)(1))

PROTON_URL_H =

SWIG_From_int((int)(1))

PROTON_REACTOR_H =

SWIG_From_int((int)(1))

PROTON_HANDLERS_H =

SWIG_From_int((int)(1))

PROTON_CID_H =

SWIG_From_int((int)(1))

CID_pn_object =

SWIG_From_int((int)(CID_pn_object))

CID_pn_void =

SWIG_From_int((int)(CID_pn_void))

CID_pn_weakref =

SWIG_From_int((int)(CID_pn_weakref))

CID_pn_string =

SWIG_From_int((int)(CID_pn_string))

CID_pn_list =

SWIG_From_int((int)(CID_pn_list))

CID_pn_map =

SWIG_From_int((int)(CID_pn_map))

CID_pn_hash =

SWIG_From_int((int)(CID_pn_hash))

CID_pn_record =

SWIG_From_int((int)(CID_pn_record))

CID_pn_collector =

SWIG_From_int((int)(CID_pn_collector))

CID_pn_event =

SWIG_From_int((int)(CID_pn_event))

CID_pn_encoder =

SWIG_From_int((int)(CID_pn_encoder))

CID_pn_decoder =

SWIG_From_int((int)(CID_pn_decoder))

CID_pn_data =

SWIG_From_int((int)(CID_pn_data))

CID_pn_connection =

SWIG_From_int((int)(CID_pn_connection))

CID_pn_session =

SWIG_From_int((int)(CID_pn_session))

CID_pn_link =

SWIG_From_int((int)(CID_pn_link))

CID_pn_delivery =

SWIG_From_int((int)(CID_pn_delivery))

CID_pn_transport =

SWIG_From_int((int)(CID_pn_transport))

CID_pn_message =

SWIG_From_int((int)(CID_pn_message))

CID_pn_reactor =

SWIG_From_int((int)(CID_pn_reactor))

CID_pn_handler =

SWIG_From_int((int)(CID_pn_handler))

CID_pn_timer =

SWIG_From_int((int)(CID_pn_timer))

CID_pn_task =

SWIG_From_int((int)(CID_pn_task))

CID_pn_io =

SWIG_From_int((int)(CID_pn_io))

CID_pn_selector =

SWIG_From_int((int)(CID_pn_selector))

CID_pn_selectable =

SWIG_From_int((int)(CID_pn_selectable))

CID_pn_url =

SWIG_From_int((int)(CID_pn_url))

CID_pn_listener =

SWIG_From_int((int)(CID_pn_listener))

CID_pn_proactor =

SWIG_From_int((int)(CID_pn_proactor))

CID_pn_listener_socket =

SWIG_From_int((int)(CID_pn_listener_socket))

Class Method Summary collapse

Class Method Details

.pn_acceptor_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22691

SWIGINTERN VALUE
_wrap_pn_acceptor_close(int argc, VALUE *argv, VALUE self) {
  pn_acceptor_t *arg1 = (pn_acceptor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_acceptor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_acceptor_t *","pn_acceptor_close", 1, argv[0] )); 
  }
  arg1 = (pn_acceptor_t *)(argp1);
  pn_acceptor_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_acceptor_set_ssl_domain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22662

SWIGINTERN VALUE
_wrap_pn_acceptor_set_ssl_domain(int argc, VALUE *argv, VALUE self) {
  pn_acceptor_t *arg1 = (pn_acceptor_t *) 0 ;
  pn_ssl_domain_t *arg2 = (pn_ssl_domain_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_acceptor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_acceptor_t *","pn_acceptor_set_ssl_domain", 1, argv[0] )); 
  }
  arg1 = (pn_acceptor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_acceptor_set_ssl_domain", 2, argv[1] )); 
  }
  arg2 = (pn_ssl_domain_t *)(argp2);
  pn_acceptor_set_ssl_domain(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_bytes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4040

SWIGINTERN VALUE
_wrap_pn_bytes(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","pn_bytes", 1, argv[0] ));
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_bytes", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = pn_bytes(arg1,(char const *)arg2);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_bytes_null ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4077

SWIGINTERN VALUE
_wrap_pn_bytes_null_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&pn_bytes_null), SWIGTYPE_p_pn_bytes_t,  0 );
  return _val;
}

.pn_cast_pn_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20512

SWIGINTERN VALUE
_wrap_pn_cast_pn_connection(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_connection", 1, argv[0] )); 
  }
  result = (pn_connection_t *)pn_cast_pn_connection(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_delivery(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20578

SWIGINTERN VALUE
_wrap_pn_cast_pn_delivery(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_delivery", 1, argv[0] )); 
  }
  result = (pn_delivery_t *)pn_cast_pn_delivery(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_link(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20556

SWIGINTERN VALUE
_wrap_pn_cast_pn_link(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_link", 1, argv[0] )); 
  }
  result = (pn_link_t *)pn_cast_pn_link(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_reactor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20622

SWIGINTERN VALUE
_wrap_pn_cast_pn_reactor(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_reactor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_reactor", 1, argv[0] )); 
  }
  result = (pn_reactor_t *)pn_cast_pn_reactor(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_selectable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20666

SWIGINTERN VALUE
_wrap_pn_cast_pn_selectable(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_selectable_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_selectable", 1, argv[0] )); 
  }
  result = (pn_selectable_t *)pn_cast_pn_selectable(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_session(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20534

SWIGINTERN VALUE
_wrap_pn_cast_pn_session(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_session", 1, argv[0] )); 
  }
  result = (pn_session_t *)pn_cast_pn_session(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_task(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20644

SWIGINTERN VALUE
_wrap_pn_cast_pn_task(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_task_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_task", 1, argv[0] )); 
  }
  result = (pn_task_t *)pn_cast_pn_task(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_task_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_cast_pn_transport(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20600

SWIGINTERN VALUE
_wrap_pn_cast_pn_transport(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_transport_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_cast_pn_transport", 1, argv[0] )); 
  }
  result = (pn_transport_t *)pn_cast_pn_transport(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_transport_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4914

SWIGINTERN VALUE
_wrap_pn_class(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_class_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_class", 1, argv[0] )); 
  }
  result = (pn_class_t *)pn_class(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_class_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class_compare(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4414

SWIGINTERN VALUE
_wrap_pn_class_compare(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  intptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_compare", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_compare", 2, argv[1] )); 
  }
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_class_compare", 3, argv[2] )); 
  }
  result = pn_class_compare((struct pn_class_t const *)arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj((intptr_t *)memcpy((intptr_t *)calloc(1,sizeof(intptr_t)),&result,sizeof(intptr_t)), SWIGTYPE_p_intptr_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class_decref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4297

SWIGINTERN VALUE
_wrap_pn_class_decref(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_decref", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_decref", 2, argv[1] )); 
  }
  result = (int)pn_class_decref((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_equals(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4450

SWIGINTERN VALUE
_wrap_pn_class_equals(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_equals", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_equals", 2, argv[1] )); 
  }
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_class_equals", 3, argv[2] )); 
  }
  result = (bool)pn_class_equals((struct pn_class_t const *)arg1,arg2,arg3);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4327

SWIGINTERN VALUE
_wrap_pn_class_free(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_free", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_free", 2, argv[1] )); 
  }
  pn_class_free((struct pn_class_t const *)arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_class_hashcode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4384

SWIGINTERN VALUE
_wrap_pn_class_hashcode(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  uintptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_hashcode", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_hashcode", 2, argv[1] )); 
  }
  result = (uintptr_t)pn_class_hashcode((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4157

SWIGINTERN VALUE
_wrap_pn_class_id(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_cid_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_id", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  result = (pn_cid_t)pn_class_id((struct pn_class_t const *)arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_incref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4237

SWIGINTERN VALUE
_wrap_pn_class_incref(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_incref", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_incref", 2, argv[1] )); 
  }
  result = (void *)pn_class_incref((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class_inspect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4486

SWIGINTERN VALUE
_wrap_pn_class_inspect(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  pn_string_t *arg3 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_inspect", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_inspect", 2, argv[1] )); 
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_string_t *","pn_class_inspect", 3, argv[2] )); 
  }
  arg3 = (pn_string_t *)(argp3);
  result = (int)pn_class_inspect((struct pn_class_t const *)arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4181

SWIGINTERN VALUE
_wrap_pn_class_name(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_name", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  result = (char *)pn_class_name((struct pn_class_t const *)arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_class_new(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4205

SWIGINTERN VALUE
_wrap_pn_class_new(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_new", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_class_new", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (void *)pn_class_new((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class_reactor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22914

SWIGINTERN VALUE
_wrap_pn_class_reactor(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  pn_reactor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_reactor", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_reactor", 2, argv[1] )); 
  }
  result = (pn_reactor_t *)pn_class_reactor((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_class_refcount(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4267

SWIGINTERN VALUE
_wrap_pn_class_refcount(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_refcount", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_refcount", 2, argv[1] )); 
  }
  result = (int)pn_class_refcount((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_class_reify(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4354

SWIGINTERN VALUE
_wrap_pn_class_reify(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  pn_class_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_class_reify", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_class_reify", 2, argv[1] )); 
  }
  result = (pn_class_t *)pn_class_reify((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_class_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_code(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6754

SWIGINTERN VALUE
_wrap_pn_code(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","pn_code", 1, argv[0] ));
  } 
  arg1 = (int)(val1);
  SWIG_contract_assert((check_error(arg1)), "Contract violation: require: (check_error(arg1))");
  
  result = (char *)pn_code(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_collector(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12591

SWIGINTERN VALUE
_wrap_pn_collector(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_collector_t *)pn_collector();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_collector_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_collector_drain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12649

SWIGINTERN VALUE
_wrap_pn_collector_drain(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_drain", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  pn_collector_drain(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_collector_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12607

SWIGINTERN VALUE
_wrap_pn_collector_free(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_free", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  pn_collector_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_collector_more(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12812

SWIGINTERN VALUE
_wrap_pn_collector_more(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_more", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (bool)pn_collector_more(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_collector_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12764

SWIGINTERN VALUE
_wrap_pn_collector_next(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_next", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (pn_event_t *)pn_collector_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_collector_peek(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12716

SWIGINTERN VALUE
_wrap_pn_collector_peek(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_peek", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (pn_event_t *)pn_collector_peek(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_collector_pop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12740

SWIGINTERN VALUE
_wrap_pn_collector_pop(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_pop", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (bool)pn_collector_pop(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_collector_prev(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12788

SWIGINTERN VALUE
_wrap_pn_collector_prev(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_prev", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (pn_event_t *)pn_collector_prev(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_collector_put(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12670

SWIGINTERN VALUE
_wrap_pn_collector_put(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  pn_class_t *arg2 = (pn_class_t *) 0 ;
  void *arg3 = (void *) 0 ;
  pn_event_type_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_put", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_class_t const *","pn_collector_put", 2, argv[1] )); 
  }
  arg2 = (pn_class_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_collector_put", 3, argv[2] )); 
  }
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "pn_event_type_t","pn_collector_put", 4, argv[3] ));
  } 
  arg4 = (pn_event_type_t)(val4);
  result = (pn_event_t *)pn_collector_put(arg1,(struct pn_class_t const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_collector_release(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12628

SWIGINTERN VALUE
_wrap_pn_collector_release(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_collector_release", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  pn_collector_release(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_compare(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4958

SWIGINTERN VALUE
_wrap_pn_compare(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  int res2 ;
  intptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_compare", 1, argv[0] )); 
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_compare", 2, argv[1] )); 
  }
  result = pn_compare(arg1,arg2);
  vresult = SWIG_NewPointerObj((intptr_t *)memcpy((intptr_t *)calloc(1,sizeof(intptr_t)),&result,sizeof(intptr_t)), SWIGTYPE_p_intptr_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7262

SWIGINTERN VALUE
_wrap_pn_condition(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_condition_t *)pn_condition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_condition_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6995

SWIGINTERN VALUE
_wrap_pn_condition_clear(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_clear", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  pn_condition_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_condition_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7230

SWIGINTERN VALUE
_wrap_pn_condition_copy(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  pn_condition_t *arg2 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_copy", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_copy", 2, argv[1] )); 
  }
  arg2 = (pn_condition_t *)(argp2);
  result = (int)pn_condition_copy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_condition_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7278

SWIGINTERN VALUE
_wrap_pn_condition_free(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_free", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  pn_condition_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_condition_get_description(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7075

SWIGINTERN VALUE
_wrap_pn_condition_get_description(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_get_description", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (char *)pn_condition_get_description(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_condition_get_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7016

SWIGINTERN VALUE
_wrap_pn_condition_get_name(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_get_name", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (char *)pn_condition_get_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_condition_info(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7134

SWIGINTERN VALUE
_wrap_pn_condition_info(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_info", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (pn_data_t *)pn_condition_info(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_condition_is_redirect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7158

SWIGINTERN VALUE
_wrap_pn_condition_is_redirect(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_is_redirect", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (bool)pn_condition_is_redirect(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_condition_is_set(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6971

SWIGINTERN VALUE
_wrap_pn_condition_is_set(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_is_set", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (bool)pn_condition_is_set(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_condition_redirect_host(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7182

SWIGINTERN VALUE
_wrap_pn_condition_redirect_host(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_redirect_host", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (char *)pn_condition_redirect_host(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_condition_redirect_port(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7206

SWIGINTERN VALUE
_wrap_pn_condition_redirect_port(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_redirect_port", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  result = (int)pn_condition_redirect_port(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_condition_set_description(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7099

SWIGINTERN VALUE
_wrap_pn_condition_set_description(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_set_description", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_condition_set_description", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_condition_set_description(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_condition_set_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7040

SWIGINTERN VALUE
_wrap_pn_condition_set_name(int argc, VALUE *argv, VALUE self) {
  pn_condition_t *arg1 = (pn_condition_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_condition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_condition_t *","pn_condition_set_name", 1, argv[0] )); 
  }
  arg1 = (pn_condition_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_condition_set_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_condition_set_name(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7299

SWIGINTERN VALUE
_wrap_pn_connection(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_connection_t *)pn_connection();
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_acceptor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22712

SWIGINTERN VALUE
_wrap_pn_connection_acceptor(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_acceptor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_acceptor", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_acceptor_t *)pn_connection_acceptor(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_acceptor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7491

SWIGINTERN VALUE
_wrap_pn_connection_attachments(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_record_t *)pn_connection_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7564

SWIGINTERN VALUE
_wrap_pn_connection_close(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_close", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_connection_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_collect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7387

SWIGINTERN VALUE
_wrap_pn_connection_collect(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  pn_collector_t *arg2 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_collect", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_collector_t *","pn_connection_collect", 2, argv[1] )); 
  }
  arg2 = (pn_collector_t *)(argp2);
  pn_connection_collect(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_collector(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7416

SWIGINTERN VALUE
_wrap_pn_connection_collector(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_collector_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_collector", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_collector_t *)pn_connection_collector(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_collector_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7608

SWIGINTERN VALUE
_wrap_pn_connection_condition(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_condition", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_condition_t *)pn_connection_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_desired_capabilities(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7940

SWIGINTERN VALUE
_wrap_pn_connection_desired_capabilities(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_desired_capabilities", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_desired_capabilities(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_bind(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20728

SWIGINTERN VALUE
_wrap_pn_connection_driver_bind(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_bind", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (int)pn_connection_driver_bind(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20995

SWIGINTERN VALUE
_wrap_pn_connection_driver_close(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_close", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  pn_connection_driver_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_driver_destroy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20752

SWIGINTERN VALUE
_wrap_pn_connection_driver_destroy(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_destroy", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  pn_connection_driver_destroy(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_driver_errorf(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21088

SWIGINTERN VALUE
_wrap_pn_connection_driver_errorf(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if (argc < 3) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_errorf", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_driver_errorf", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_connection_driver_errorf", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  pn_connection_driver_errorf(arg1,(char const *)arg2,(char const *)arg3,arg4);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_connection_driver_finished(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21064

SWIGINTERN VALUE
_wrap_pn_connection_driver_finished(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_finished", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (bool)pn_connection_driver_finished(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_has_event(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21040

SWIGINTERN VALUE
_wrap_pn_connection_driver_has_event(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_has_event", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (bool)pn_connection_driver_has_event(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_init(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20688

SWIGINTERN VALUE
_wrap_pn_connection_driver_init(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  pn_connection_t *arg2 = (pn_connection_t *) 0 ;
  pn_transport_t *arg3 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_init", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_driver_init", 2, argv[1] )); 
  }
  arg2 = (pn_connection_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_transport_t *","pn_connection_driver_init", 3, argv[2] )); 
  }
  arg3 = (pn_transport_t *)(argp3);
  result = (int)pn_connection_driver_init(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_log(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21156

SWIGINTERN VALUE
_wrap_pn_connection_driver_log(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_log", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_driver_log", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_connection_driver_log(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection_driver_next_event(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21016

SWIGINTERN VALUE
_wrap_pn_connection_driver_next_event(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_next_event", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (pn_event_t *)pn_connection_driver_next_event(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_ptr(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21188

SWIGINTERN VALUE
_wrap_pn_connection_driver_ptr(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_driver_t **result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_driver_ptr", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_connection_driver_t **)pn_connection_driver_ptr(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_pn_connection_driver_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_read_buffer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20797

SWIGINTERN VALUE
_wrap_pn_connection_driver_read_buffer(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_rwbytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_read_buffer", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = pn_connection_driver_read_buffer(arg1);
  vresult = SWIG_NewPointerObj((pn_rwbytes_t *)memcpy((pn_rwbytes_t *)calloc(1,sizeof(pn_rwbytes_t)),&result,sizeof(pn_rwbytes_t)), SWIGTYPE_p_pn_rwbytes_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_read_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20850

SWIGINTERN VALUE
_wrap_pn_connection_driver_read_close(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_read_close", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  pn_connection_driver_read_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_driver_read_closed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20871

SWIGINTERN VALUE
_wrap_pn_connection_driver_read_closed(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_read_closed", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (bool)pn_connection_driver_read_closed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_read_done(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20821

SWIGINTERN VALUE
_wrap_pn_connection_driver_read_done(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_read_done", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_connection_driver_read_done", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  pn_connection_driver_read_done(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_driver_release_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20773

SWIGINTERN VALUE
_wrap_pn_connection_driver_release_connection(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_release_connection", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (pn_connection_t *)pn_connection_driver_release_connection(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_write_buffer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20895

SWIGINTERN VALUE
_wrap_pn_connection_driver_write_buffer(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_write_buffer", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = pn_connection_driver_write_buffer(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_write_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20950

SWIGINTERN VALUE
_wrap_pn_connection_driver_write_close(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_write_close", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  pn_connection_driver_write_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_driver_write_closed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20971

SWIGINTERN VALUE
_wrap_pn_connection_driver_write_closed(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_write_closed", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (bool)pn_connection_driver_write_closed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_driver_write_done(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20921

SWIGINTERN VALUE
_wrap_pn_connection_driver_write_done(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pn_connection_driver_write_done", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_connection_driver_write_done", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  pn_connection_driver_write_done(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7361

SWIGINTERN VALUE
_wrap_pn_connection_error(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_error", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_connection_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7317

SWIGINTERN VALUE
_wrap_pn_connection_free(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_free", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_connection_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_get_container(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7656

SWIGINTERN VALUE
_wrap_pn_connection_get_container(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_get_container", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_connection_get_container(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_connection_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7440

SWIGINTERN VALUE
_wrap_pn_connection_get_context(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (void *)pn_connection_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_get_hostname(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7804

SWIGINTERN VALUE
_wrap_pn_connection_get_hostname(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_get_hostname", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_connection_get_hostname(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_connection_get_user(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7780

SWIGINTERN VALUE
_wrap_pn_connection_get_user(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_get_user", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (char *)pn_connection_get_user(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_connection_offered_capabilities(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7916

SWIGINTERN VALUE
_wrap_pn_connection_offered_capabilities(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_offered_capabilities", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_offered_capabilities(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_open(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7541

SWIGINTERN VALUE
_wrap_pn_connection_open(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_open", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_connection_open(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_properties(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7964

SWIGINTERN VALUE
_wrap_pn_connection_properties(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_properties", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_properties(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_release(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7340

SWIGINTERN VALUE
_wrap_pn_connection_release(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_release", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  pn_connection_release(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_remote_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7632

SWIGINTERN VALUE
_wrap_pn_connection_remote_condition(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_condition", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_condition_t *)pn_connection_remote_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_remote_container(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7864

SWIGINTERN VALUE
_wrap_pn_connection_remote_container(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_container", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_connection_remote_container(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_connection_remote_desired_capabilities(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8012

SWIGINTERN VALUE
_wrap_pn_connection_remote_desired_capabilities(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_desired_capabilities", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_remote_desired_capabilities(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_remote_hostname(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7890

SWIGINTERN VALUE
_wrap_pn_connection_remote_hostname(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_hostname", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_connection_remote_hostname(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_connection_remote_offered_capabilities(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7988

SWIGINTERN VALUE
_wrap_pn_connection_remote_offered_capabilities(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_offered_capabilities", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_remote_offered_capabilities(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_remote_properties(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8036

SWIGINTERN VALUE
_wrap_pn_connection_remote_properties(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_remote_properties", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_data_t *)pn_connection_remote_properties(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_connection_reset(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7587

SWIGINTERN VALUE
_wrap_pn_connection_reset(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_reset", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  pn_connection_reset(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_set_container(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7682

SWIGINTERN VALUE
_wrap_pn_connection_set_container(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_set_container", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_set_container", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_connection_set_container(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7464

SWIGINTERN VALUE
_wrap_pn_connection_set_context(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_connection_set_context", 2, argv[1] )); 
  }
  pn_connection_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_connection_set_hostname(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7830

SWIGINTERN VALUE
_wrap_pn_connection_set_hostname(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_set_hostname", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_set_hostname", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_connection_set_hostname(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection_set_password(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7748

SWIGINTERN VALUE
_wrap_pn_connection_set_password(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_set_password", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_set_password", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_connection_set_password(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection_set_user(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7716

SWIGINTERN VALUE
_wrap_pn_connection_set_user(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_set_user", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_connection_set_user", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_connection_set_user(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_connection_state(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 7515

SWIGINTERN VALUE
_wrap_pn_connection_state(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_state_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_state", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_state_t)pn_connection_state(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_connection_transport(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8060

SWIGINTERN VALUE
_wrap_pn_connection_transport(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_transport_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_connection_transport", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  result = (pn_transport_t *)pn_connection_transport(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_transport_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_data(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18239

SWIGINTERN VALUE
_wrap_pn_data(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","pn_data", 1, argv[0] ));
  } 
  arg1 = (size_t)(val1);
  result = (pn_data_t *)pn_data(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_data_append(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20321

SWIGINTERN VALUE
_wrap_pn_data_append(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_data_t *arg2 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_append", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_append", 2, argv[1] )); 
  }
  arg2 = (pn_data_t *)(argp2);
  result = (int)pn_data_append(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_appendn(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20353

SWIGINTERN VALUE
_wrap_pn_data_appendn(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_data_t *arg2 = (pn_data_t *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_appendn", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_appendn", 2, argv[1] )); 
  }
  arg2 = (pn_data_t *)(argp2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pn_data_appendn", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  result = (int)pn_data_appendn(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18404

SWIGINTERN VALUE
_wrap_pn_data_clear(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_clear", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_data_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20289

SWIGINTERN VALUE
_wrap_pn_data_copy(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_data_t *arg2 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_copy", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_copy", 2, argv[1] )); 
  }
  arg2 = (pn_data_t *)(argp2);
  result = (int)pn_data_copy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_decode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18759

SWIGINTERN VALUE
_wrap_pn_data_decode(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_decode", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_data_decode", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_data_decode", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (ssize_t)pn_data_decode(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_dump(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20491

SWIGINTERN VALUE
_wrap_pn_data_dump(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_dump", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_dump(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_data_encode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18692

SWIGINTERN VALUE
_wrap_pn_data_encode(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_encode", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_data_encode", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_data_encode", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (ssize_t)pn_data_encode(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_encoded_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18735

SWIGINTERN VALUE
_wrap_pn_data_encoded_size(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_encoded_size", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (ssize_t)pn_data_encoded_size(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_enter(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18518

SWIGINTERN VALUE
_wrap_pn_data_enter(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_enter", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_enter(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_errno(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18284

SWIGINTERN VALUE
_wrap_pn_data_errno(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_errno", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_errno(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18308

SWIGINTERN VALUE
_wrap_pn_data_error(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_error", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_error_t *)pn_data_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_data_exit(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18542

SWIGINTERN VALUE
_wrap_pn_data_exit(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_exit", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_exit(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_fill(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18332

SWIGINTERN VALUE
_wrap_pn_data_fill(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if (argc < 2) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_fill", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_data_fill", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_data_fill(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_format(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18649

SWIGINTERN VALUE
_wrap_pn_data_format(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_format", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_data_format", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "size_t *","pn_data_format", 3, argv[2] )); 
  }
  arg3 = (size_t *)(argp3);
  result = (int)pn_data_format(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18263

SWIGINTERN VALUE
_wrap_pn_data_free(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_free", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_data_get_array(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19637

SWIGINTERN VALUE
_wrap_pn_data_get_array(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_array", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (size_t)pn_data_get_array(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_array_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19685

SWIGINTERN VALUE
_wrap_pn_data_get_array_type(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_type_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_array_type", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_type_t)pn_data_get_array_type(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_binary(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20185

SWIGINTERN VALUE
_wrap_pn_data_get_binary(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_binary", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_binary(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_bool(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19757

SWIGINTERN VALUE
_wrap_pn_data_get_bool(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_bool", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_get_bool(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_byte(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19805

SWIGINTERN VALUE
_wrap_pn_data_get_byte(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_byte", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int8_t)pn_data_get_byte(arg1);
  vresult = SWIG_From_signed_SS_char((signed char)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_bytes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20263

SWIGINTERN VALUE
_wrap_pn_data_get_bytes(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_bytes", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_bytes(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_char(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19925

SWIGINTERN VALUE
_wrap_pn_data_get_char(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_char_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_char", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_char_t)pn_data_get_char(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_decimal128(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20121

SWIGINTERN VALUE
_wrap_pn_data_get_decimal128(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_decimal128_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_decimal128", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_decimal128(arg1);
  {
    int index;
    
    vresult = rb_ary_new2(16);
    for(index = 0; index < 16; index++)
    {
      rb_ary_store(vresult, 16 - (index + 1), CHR2FIX((&result)->bytes[index]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_decimal32(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20069

SWIGINTERN VALUE
_wrap_pn_data_get_decimal32(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_decimal32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_decimal32", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_decimal32_t)pn_data_get_decimal32(arg1);
  {
    vresult = UINT2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_decimal64(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20095

SWIGINTERN VALUE
_wrap_pn_data_get_decimal64(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_decimal64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_decimal64", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_decimal64_t)pn_data_get_decimal64(arg1);
  {
    vresult = ULL2NUM(result);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_double(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20045

SWIGINTERN VALUE
_wrap_pn_data_get_double(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_double", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (double)pn_data_get_double(arg1);
  vresult = SWIG_From_double((double)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_float(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20021

SWIGINTERN VALUE
_wrap_pn_data_get_float(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_float", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (float)pn_data_get_float(arg1);
  vresult = SWIG_From_float((float)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_int(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19901

SWIGINTERN VALUE
_wrap_pn_data_get_int(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_int", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int32_t)pn_data_get_int(arg1);
  vresult = SWIG_From_long((long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_list(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19589

SWIGINTERN VALUE
_wrap_pn_data_get_list(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_list", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (size_t)pn_data_get_list(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_long(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19973

SWIGINTERN VALUE
_wrap_pn_data_get_long(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_long", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int64_t)pn_data_get_long(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_map(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19613

SWIGINTERN VALUE
_wrap_pn_data_get_map(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_map", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (size_t)pn_data_get_map(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_short(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19853

SWIGINTERN VALUE
_wrap_pn_data_get_short(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int16_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_short", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int16_t)pn_data_get_short(arg1);
  vresult = SWIG_From_short((short)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_string(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20211

SWIGINTERN VALUE
_wrap_pn_data_get_string(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_string", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_string(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_symbol(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20237

SWIGINTERN VALUE
_wrap_pn_data_get_symbol(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_symbol", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_symbol(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_timestamp(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19997

SWIGINTERN VALUE
_wrap_pn_data_get_timestamp(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_timestamp", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_timestamp_t)pn_data_get_timestamp(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_ubyte(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19781

SWIGINTERN VALUE
_wrap_pn_data_get_ubyte(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_ubyte", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (uint8_t)pn_data_get_ubyte(arg1);
  vresult = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_uint(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19877

SWIGINTERN VALUE
_wrap_pn_data_get_uint(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_uint", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (uint32_t)pn_data_get_uint(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_ulong(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19949

SWIGINTERN VALUE
_wrap_pn_data_get_ulong(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_ulong", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (uint64_t)pn_data_get_ulong(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_ushort(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19829

SWIGINTERN VALUE
_wrap_pn_data_get_ushort(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint16_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_ushort", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (uint16_t)pn_data_get_ushort(arg1);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_get_uuid(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20153

SWIGINTERN VALUE
_wrap_pn_data_get_uuid(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_uuid_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_get_uuid", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = pn_data_get_uuid(arg1);
  {
    int index;
    
    vresult = rb_ary_new2(16);
    for(index = 0; index < 16; index++)
    {
      rb_ary_store(vresult, 16 - (index + 1), CHR2FIX((&result)->bytes[index]));
    }
  }
  return vresult;
fail:
  return Qnil;
}

.pn_data_is_array_described(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19661

SWIGINTERN VALUE
_wrap_pn_data_is_array_described(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_is_array_described", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_is_array_described(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_is_described(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19709

SWIGINTERN VALUE
_wrap_pn_data_is_described(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_is_described", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_is_described(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_is_null(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19733

SWIGINTERN VALUE
_wrap_pn_data_is_null(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_is_null", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_is_null(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_lookup(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18566

SWIGINTERN VALUE
_wrap_pn_data_lookup(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_lookup", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_data_lookup", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (bool)pn_data_lookup(arg1,(char const *)arg2);
  vresult = SWIG_From_bool((bool)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_narrow(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20393

SWIGINTERN VALUE
_wrap_pn_data_narrow(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_narrow", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_narrow(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_data_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18470

SWIGINTERN VALUE
_wrap_pn_data_next(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_next", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_next(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_point(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20435

SWIGINTERN VALUE
_wrap_pn_data_point(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handle_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_point", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_handle_t)pn_data_point(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_prev(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18494

SWIGINTERN VALUE
_wrap_pn_data_prev(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_prev", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (bool)pn_data_prev(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_print(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18625

SWIGINTERN VALUE
_wrap_pn_data_print(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_print", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_print(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_array(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18850

SWIGINTERN VALUE
_wrap_pn_data_put_array(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  bool arg2 ;
  pn_type_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_array", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_data_put_array", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "pn_type_t","pn_data_put_array", 3, argv[2] ));
  } 
  arg3 = (pn_type_t)(val3);
  result = (int)pn_data_put_array(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_binary(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19478

SWIGINTERN VALUE
_wrap_pn_data_put_binary(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_bytes_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_binary", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    if (argv[1] == Qnil) {
      (&arg2)->start = NULL;
      (&arg2)->size = 0;
    } else {
      (&arg2)->start = RSTRING_PTR(argv[1]);
      if (!(&arg2)->start) {
        (&arg2)->size = 0;
      }
      (&arg2)->size = RSTRING_LEN(argv[1]);
    }
  }
  result = (int)pn_data_put_binary(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_bool(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18938

SWIGINTERN VALUE
_wrap_pn_data_put_bool(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_bool", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_data_put_bool", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  result = (int)pn_data_put_bool(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_byte(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19002

SWIGINTERN VALUE
_wrap_pn_data_put_byte(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  int8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  signed char val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_byte", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_signed_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int8_t","pn_data_put_byte", 2, argv[1] ));
  } 
  arg2 = (int8_t)(val2);
  result = (int)pn_data_put_byte(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_char(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19162

SWIGINTERN VALUE
_wrap_pn_data_put_char(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_char_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_char", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_char_t","pn_data_put_char", 2, argv[1] ));
  } 
  arg2 = (pn_char_t)(val2);
  result = (int)pn_data_put_char(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_decimal128(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19410

SWIGINTERN VALUE
_wrap_pn_data_put_decimal128(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_decimal128_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_decimal128", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    int index;
    
    for(index = 0; index < 16; index++)
    {
      VALUE element = rb_ary_entry(argv[1], index);
      (&arg2)->bytes[16 - (index + 1)] = FIX2INT(element);
    }
  }
  result = (int)pn_data_put_decimal128(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_decimal32(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19354

SWIGINTERN VALUE
_wrap_pn_data_put_decimal32(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_decimal32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_decimal32", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    arg2 = NUM2UINT(argv[1]);
  }
  result = (int)pn_data_put_decimal32(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_decimal64(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19382

SWIGINTERN VALUE
_wrap_pn_data_put_decimal64(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_decimal64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_decimal64", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    arg2 = NUM2ULL(argv[1]);
  }
  result = (int)pn_data_put_decimal64(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_described(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18890

SWIGINTERN VALUE
_wrap_pn_data_put_described(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_described", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_put_described(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_double(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19322

SWIGINTERN VALUE
_wrap_pn_data_put_double(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_double", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","pn_data_put_double", 2, argv[1] ));
  } 
  arg2 = (double)(val2);
  result = (int)pn_data_put_double(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_float(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19290

SWIGINTERN VALUE
_wrap_pn_data_put_float(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_float", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","pn_data_put_float", 2, argv[1] ));
  } 
  arg2 = (float)(val2);
  result = (int)pn_data_put_float(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_int(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19130

SWIGINTERN VALUE
_wrap_pn_data_put_int(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  int32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_int", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int32_t","pn_data_put_int", 2, argv[1] ));
  } 
  arg2 = (int32_t)(val2);
  result = (int)pn_data_put_int(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_list(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18802

SWIGINTERN VALUE
_wrap_pn_data_put_list(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_list", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_put_list(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_long(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19226

SWIGINTERN VALUE
_wrap_pn_data_put_long(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  int64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_long", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int64_t","pn_data_put_long", 2, argv[1] ));
  } 
  arg2 = (int64_t)(val2);
  result = (int)pn_data_put_long(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_map(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18826

SWIGINTERN VALUE
_wrap_pn_data_put_map(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_map", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_put_map(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_null(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18914

SWIGINTERN VALUE
_wrap_pn_data_put_null(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_null", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (int)pn_data_put_null(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_short(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19066

SWIGINTERN VALUE
_wrap_pn_data_put_short(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  int16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_short", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int16_t","pn_data_put_short", 2, argv[1] ));
  } 
  arg2 = (int16_t)(val2);
  result = (int)pn_data_put_short(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_string(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19515

SWIGINTERN VALUE
_wrap_pn_data_put_string(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_bytes_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_string", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    if (argv[1] == Qnil) {
      (&arg2)->start = NULL;
      (&arg2)->size = 0;
    } else {
      (&arg2)->start = RSTRING_PTR(argv[1]);
      if (!(&arg2)->start) {
        (&arg2)->size = 0;
      }
      (&arg2)->size = RSTRING_LEN(argv[1]);
    }
  }
  result = (int)pn_data_put_string(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_symbol(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19552

SWIGINTERN VALUE
_wrap_pn_data_put_symbol(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_bytes_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_symbol", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    if (argv[1] == Qnil) {
      (&arg2)->start = NULL;
      (&arg2)->size = 0;
    } else {
      (&arg2)->start = RSTRING_PTR(argv[1]);
      if (!(&arg2)->start) {
        (&arg2)->size = 0;
      }
      (&arg2)->size = RSTRING_LEN(argv[1]);
    }
  }
  result = (int)pn_data_put_symbol(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_timestamp(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19258

SWIGINTERN VALUE
_wrap_pn_data_put_timestamp(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_timestamp", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_data_put_timestamp", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  result = (int)pn_data_put_timestamp(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_ubyte(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18970

SWIGINTERN VALUE
_wrap_pn_data_put_ubyte(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_ubyte", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","pn_data_put_ubyte", 2, argv[1] ));
  } 
  arg2 = (uint8_t)(val2);
  result = (int)pn_data_put_ubyte(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_uint(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19098

SWIGINTERN VALUE
_wrap_pn_data_put_uint(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_uint", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint32_t","pn_data_put_uint", 2, argv[1] ));
  } 
  arg2 = (uint32_t)(val2);
  result = (int)pn_data_put_uint(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_ulong(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19194

SWIGINTERN VALUE
_wrap_pn_data_put_ulong(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_ulong", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","pn_data_put_ulong", 2, argv[1] ));
  } 
  arg2 = (uint64_t)(val2);
  result = (int)pn_data_put_ulong(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_ushort(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19034

SWIGINTERN VALUE
_wrap_pn_data_put_ushort(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_ushort", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint16_t","pn_data_put_ushort", 2, argv[1] ));
  } 
  arg2 = (uint16_t)(val2);
  result = (int)pn_data_put_ushort(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_put_uuid(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 19444

SWIGINTERN VALUE
_wrap_pn_data_put_uuid(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_uuid_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_put_uuid", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  {
    int index;
    
    for(index = 0; index < 16; index++)
    {
      VALUE element = rb_ary_entry(argv[1], index);
      (&arg2)->bytes[16 - (index + 1)] = FIX2INT(element);
    }
  }
  result = (int)pn_data_put_uuid(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_restore(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20459

SWIGINTERN VALUE
_wrap_pn_data_restore(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_restore", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_data_restore", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (bool)pn_data_restore(arg1,(void const *)arg2);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_rewind(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18449

SWIGINTERN VALUE
_wrap_pn_data_rewind(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_rewind", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_rewind(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_data_scan(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18368

SWIGINTERN VALUE
_wrap_pn_data_scan(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if (argc < 2) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_scan", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_data_scan", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_data_scan(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_data_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18425

SWIGINTERN VALUE
_wrap_pn_data_size(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_size", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (size_t)pn_data_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18601

SWIGINTERN VALUE
_wrap_pn_data_type(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_type_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_type", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  result = (pn_type_t)pn_data_type(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_data_widen(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 20414

SWIGINTERN VALUE
_wrap_pn_data_widen(int argc, VALUE *argv, VALUE self) {
  pn_data_t *arg1 = (pn_data_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_data_t *","pn_data_widen", 1, argv[0] )); 
  }
  arg1 = (pn_data_t *)(argp1);
  pn_data_widen(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_decref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4851

SWIGINTERN VALUE
_wrap_pn_decref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_decref", 1, argv[0] )); 
  }
  result = (int)pn_decref(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3076

SWIGINTERN VALUE
_wrap_pn_delivery(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","wrap_pn_delivery", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, &size2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","wrap_pn_delivery", 2, argv[1] ));
  }  
  arg2 = (char *)(buf2);
  arg3 = (size_t)(size2 - 1);
  result = (pn_delivery_t *)wrap_pn_delivery(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_delivery_abort(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10891

SWIGINTERN VALUE
_wrap_pn_delivery_abort(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_abort", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  pn_delivery_abort(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_aborted(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10713

SWIGINTERN VALUE
_wrap_pn_delivery_aborted(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_aborted", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (bool)pn_delivery_aborted(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10487

SWIGINTERN VALUE
_wrap_pn_delivery_attachments(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (pn_record_t *)pn_delivery_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_buffered(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10958

SWIGINTERN VALUE
_wrap_pn_delivery_buffered(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_buffered", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (bool)pn_delivery_buffered(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10844

SWIGINTERN VALUE
_wrap_pn_delivery_clear(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_clear", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_delivery_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_current(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10867

SWIGINTERN VALUE
_wrap_pn_delivery_current(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_current", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (bool)pn_delivery_current(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_dump(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10935

SWIGINTERN VALUE
_wrap_pn_delivery_dump(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_dump", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_delivery_dump(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10436

SWIGINTERN VALUE
_wrap_pn_delivery_get_context(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (void *)pn_delivery_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_link(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10511

SWIGINTERN VALUE
_wrap_pn_delivery_link(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_link", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_link_t *)pn_delivery_link(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_local(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10537

SWIGINTERN VALUE
_wrap_pn_delivery_local(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_disposition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_local", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (pn_disposition_t *)pn_delivery_local(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_local_state(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10561

SWIGINTERN VALUE
_wrap_pn_delivery_local_state(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_local_state", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (uint64_t)pn_delivery_local_state(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_partial(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10689

SWIGINTERN VALUE
_wrap_pn_delivery_partial(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_partial", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (bool)pn_delivery_partial(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_pending(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10663

SWIGINTERN VALUE
_wrap_pn_delivery_pending(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_pending", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (size_t)pn_delivery_pending(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_readable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10763

SWIGINTERN VALUE
_wrap_pn_delivery_readable(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_readable", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_delivery_readable(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_remote(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10587

SWIGINTERN VALUE
_wrap_pn_delivery_remote(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_disposition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_remote", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  result = (pn_disposition_t *)pn_delivery_remote(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_remote_state(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10611

SWIGINTERN VALUE
_wrap_pn_delivery_remote_state(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_remote_state", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (uint64_t)pn_delivery_remote_state(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10460

SWIGINTERN VALUE
_wrap_pn_delivery_set_context(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_delivery_set_context", 2, argv[1] )); 
  }
  pn_delivery_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_settle(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10912

SWIGINTERN VALUE
_wrap_pn_delivery_settle(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_settle", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_delivery_settle(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_settled(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10637

SWIGINTERN VALUE
_wrap_pn_delivery_settled(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_settled", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_delivery_settled(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_tag(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3114

SWIGINTERN VALUE
_wrap_pn_delivery_tag(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  char **arg2 = (char **) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *temp2 = 0 ;
  size_t tempn2 ;
  VALUE vresult = Qnil;
  
  arg2 = &temp2; arg3 = &tempn2;
  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_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","wrap_pn_delivery_tag", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  wrap_pn_delivery_tag(arg1,arg2,arg3);
  if (*arg2) {
    vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(*arg2,*arg3));
    free(*arg2);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_update(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10815

SWIGINTERN VALUE
_wrap_pn_delivery_update(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_update", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","pn_delivery_update", 2, argv[1] ));
  } 
  arg2 = (uint64_t)(val2);
  pn_delivery_update(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_delivery_updated(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10789

SWIGINTERN VALUE
_wrap_pn_delivery_updated(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_updated", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_delivery_updated(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_delivery_writable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10737

SWIGINTERN VALUE
_wrap_pn_delivery_writable(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_delivery_writable", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_delivery_writable(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_annotations(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11342

SWIGINTERN VALUE
_wrap_pn_disposition_annotations(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_annotations", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (pn_data_t *)pn_disposition_annotations(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11082

SWIGINTERN VALUE
_wrap_pn_disposition_condition(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_condition", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (pn_condition_t *)pn_disposition_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_data(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11106

SWIGINTERN VALUE
_wrap_pn_disposition_data(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_data", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (pn_data_t *)pn_disposition_data(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_get_section_number(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11130

SWIGINTERN VALUE
_wrap_pn_disposition_get_section_number(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_get_section_number", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (uint32_t)pn_disposition_get_section_number(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_get_section_offset(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11183

SWIGINTERN VALUE
_wrap_pn_disposition_get_section_offset(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_get_section_offset", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (uint64_t)pn_disposition_get_section_offset(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_is_failed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11236

SWIGINTERN VALUE
_wrap_pn_disposition_is_failed(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_is_failed", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (bool)pn_disposition_is_failed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_is_undeliverable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11289

SWIGINTERN VALUE
_wrap_pn_disposition_is_undeliverable(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_is_undeliverable", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (bool)pn_disposition_is_undeliverable(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_set_failed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11260

SWIGINTERN VALUE
_wrap_pn_disposition_set_failed(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_set_failed", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_disposition_set_failed", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_disposition_set_failed(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_disposition_set_section_number(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11154

SWIGINTERN VALUE
_wrap_pn_disposition_set_section_number(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_set_section_number", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint32_t","pn_disposition_set_section_number", 2, argv[1] ));
  } 
  arg2 = (uint32_t)(val2);
  pn_disposition_set_section_number(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_disposition_set_section_offset(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11207

SWIGINTERN VALUE
_wrap_pn_disposition_set_section_offset(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_set_section_offset", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","pn_disposition_set_section_offset", 2, argv[1] ));
  } 
  arg2 = (uint64_t)(val2);
  pn_disposition_set_section_offset(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_disposition_set_undeliverable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11313

SWIGINTERN VALUE
_wrap_pn_disposition_set_undeliverable(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_set_undeliverable", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_disposition_set_undeliverable", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_disposition_set_undeliverable(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_disposition_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11034

SWIGINTERN VALUE
_wrap_pn_disposition_type(int argc, VALUE *argv, VALUE self) {
  pn_disposition_t *arg1 = (pn_disposition_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_disposition_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_disposition_t *","pn_disposition_type", 1, argv[0] )); 
  }
  arg1 = (pn_disposition_t *)(argp1);
  result = (uint64_t)pn_disposition_type(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_disposition_type_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11058

SWIGINTERN VALUE
_wrap_pn_disposition_type_name(int argc, VALUE *argv, VALUE self) {
  uint64_t arg1 ;
  unsigned long long val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "uint64_t","pn_disposition_type_name", 1, argv[0] ));
  } 
  arg1 = (uint64_t)(val1);
  result = (char *)pn_disposition_type_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_dtag(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10399

SWIGINTERN VALUE
_wrap_pn_dtag(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  size_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  pn_delivery_tag_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","pn_dtag", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_dtag", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = pn_dtag((char const *)arg1,arg2);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.pn_equals(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4986

SWIGINTERN VALUE
_wrap_pn_equals(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  int res2 ;
  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(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_equals", 1, argv[0] )); 
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_equals", 2, argv[1] )); 
  }
  result = (bool)pn_equals(arg1,arg2);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6780

SWIGINTERN VALUE
_wrap_pn_error(int argc, VALUE *argv, VALUE self) {
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_error_t *)pn_error();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_error_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6819

SWIGINTERN VALUE
_wrap_pn_error_clear(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_clear", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_error_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_error_code(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6887

SWIGINTERN VALUE
_wrap_pn_error_code(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_code", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_error_code(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_error_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6939

SWIGINTERN VALUE
_wrap_pn_error_copy(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 0 ;
  pn_error_t *arg2 = (pn_error_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_copy", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_copy", 2, argv[1] )); 
  }
  arg2 = (pn_error_t *)(argp2);
  result = (int)pn_error_copy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_error_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6796

SWIGINTERN VALUE
_wrap_pn_error_free(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_free", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_error_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_error_set(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6842

SWIGINTERN VALUE
_wrap_pn_error_set(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_set", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_error_set", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_error_set", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_error_set(arg1,arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_error_text(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6913

SWIGINTERN VALUE
_wrap_pn_error_text(int argc, VALUE *argv, VALUE self) {
  pn_error_t *arg1 = (pn_error_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_error_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_error_t *","pn_error_text", 1, argv[0] )); 
  }
  arg1 = (pn_error_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_error_text(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_event_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13028

SWIGINTERN VALUE
_wrap_pn_event_attachments(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_record_t *)pn_event_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_batch_connection_driver(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21132

SWIGINTERN VALUE
_wrap_pn_event_batch_connection_driver(int argc, VALUE *argv, VALUE self) {
  pn_event_batch_t *arg1 = (pn_event_batch_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_driver_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_batch_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_batch_t *","pn_event_batch_connection_driver", 1, argv[0] )); 
  }
  arg1 = (pn_event_batch_t *)(argp1);
  result = (pn_connection_driver_t *)pn_event_batch_connection_driver(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_batch_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13076

SWIGINTERN VALUE
_wrap_pn_event_batch_next(int argc, VALUE *argv, VALUE self) {
  pn_event_batch_t *arg1 = (pn_event_batch_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_batch_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_batch_t *","pn_event_batch_next", 1, argv[0] )); 
  }
  arg1 = (pn_event_batch_t *)(argp1);
  result = (pn_event_t *)pn_event_batch_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_class(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12860

SWIGINTERN VALUE
_wrap_pn_event_class(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_class_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_class", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_class_t *)pn_event_class(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_class_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13052

SWIGINTERN VALUE
_wrap_pn_event_condition(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  struct pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_condition", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (struct pn_condition_t *)pn_event_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12908

SWIGINTERN VALUE
_wrap_pn_event_connection(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_connection", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_connection_t *)pn_event_connection(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12884

SWIGINTERN VALUE
_wrap_pn_event_context(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_context", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (void *)pn_event_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13100

SWIGINTERN VALUE
_wrap_pn_event_copy(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_copy", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_event_t *)pn_event_copy(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_event_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_delivery(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12980

SWIGINTERN VALUE
_wrap_pn_event_delivery(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_delivery", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_delivery_t *)pn_event_delivery(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_link(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12956

SWIGINTERN VALUE
_wrap_pn_event_link(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_link", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_link_t *)pn_event_link(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_reactor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22966

SWIGINTERN VALUE
_wrap_pn_event_reactor(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_reactor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_reactor", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_reactor_t *)pn_event_reactor(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_root(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 23043

SWIGINTERN VALUE
_wrap_pn_event_root(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_root", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_handler_t *)pn_event_root(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_session(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12932

SWIGINTERN VALUE
_wrap_pn_event_session(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_session", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_session_t *)pn_event_session(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_transport(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13004

SWIGINTERN VALUE
_wrap_pn_event_transport(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_transport_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_transport", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_transport_t *)pn_event_transport(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_transport_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_event_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12836

SWIGINTERN VALUE
_wrap_pn_event_type(int argc, VALUE *argv, VALUE self) {
  pn_event_t *arg1 = (pn_event_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_event_type_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_event_t *","pn_event_type", 1, argv[0] )); 
  }
  arg1 = (pn_event_t *)(argp1);
  result = (pn_event_type_t)pn_event_type(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_event_type_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12567

SWIGINTERN VALUE
_wrap_pn_event_type_name(int argc, VALUE *argv, VALUE self) {
  pn_event_type_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "pn_event_type_t","pn_event_type_name", 1, argv[0] ));
  } 
  arg1 = (pn_event_type_t)(val1);
  result = (char *)pn_event_type_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_flowcontroller(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 23099

SWIGINTERN VALUE
_wrap_pn_flowcontroller(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  pn_flowcontroller_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","pn_flowcontroller", 1, argv[0] ));
  } 
  arg1 = (int)(val1);
  result = (pn_flowcontroller_t *)pn_flowcontroller(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4895

SWIGINTERN VALUE
_wrap_pn_free(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_free", 1, argv[0] )); 
  }
  pn_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21657

SWIGINTERN VALUE
_wrap_pn_handler(int argc, VALUE *argv, VALUE self) {
  void (*arg1)(pn_handler_t *,pn_event_t *,pn_event_type_t) = (void (*)(pn_handler_t *,pn_event_t *,pn_event_type_t)) 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_struct_pn_handler_t_p_struct_pn_event_t_enum_pn_event_type_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_handler_t *,pn_event_t *,pn_event_type_t)","pn_handler", 1, argv[0] )); 
    }
  }
  result = (pn_handler_t *)pn_handler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_handler_add(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21763

SWIGINTERN VALUE
_wrap_pn_handler_add(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 0 ;
  pn_handler_t *arg2 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_add", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_add", 2, argv[1] )); 
  }
  arg2 = (pn_handler_t *)(argp2);
  pn_handler_add(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_handler_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21792

SWIGINTERN VALUE
_wrap_pn_handler_clear(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_clear", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  pn_handler_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_handler_dispatch(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21813

SWIGINTERN VALUE
_wrap_pn_handler_dispatch(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 0 ;
  pn_event_t *arg2 = (pn_event_t *) 0 ;
  pn_event_type_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_dispatch", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_event_t *","pn_handler_dispatch", 2, argv[1] )); 
  }
  arg2 = (pn_event_t *)(argp2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "pn_event_type_t","pn_handler_dispatch", 3, argv[2] ));
  } 
  arg3 = (pn_event_type_t)(val3);
  pn_handler_dispatch(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

.pn_handler_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21718

SWIGINTERN VALUE
_wrap_pn_handler_free(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_free", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  pn_handler_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_handler_mem(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21739

SWIGINTERN VALUE
_wrap_pn_handler_mem(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pn_handler_mem", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  result = (void *)pn_handler_mem(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_handler_new(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21680

SWIGINTERN VALUE
_wrap_pn_handler_new(int argc, VALUE *argv, VALUE self) {
  void (*arg1)(pn_handler_t *,pn_event_t *,pn_event_type_t) = (void (*)(pn_handler_t *,pn_event_t *,pn_event_type_t)) 0 ;
  size_t arg2 ;
  void (*arg3)(pn_handler_t *) = (void (*)(pn_handler_t *)) 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg1), SWIGTYPE_p_f_p_struct_pn_handler_t_p_struct_pn_event_t_enum_pn_event_type_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_handler_t *,pn_event_t *,pn_event_type_t)","pn_handler_new", 1, argv[0] )); 
    }
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_handler_new", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  {
    int res = SWIG_ConvertFunctionPtr(argv[2], (void**)(&arg3), SWIGTYPE_p_f_p_struct_pn_handler_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_handler_t *)","pn_handler_new", 3, argv[2] )); 
    }
  }
  result = (pn_handler_t *)pn_handler_new(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_handshaker(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 23067

SWIGINTERN VALUE
_wrap_pn_handshaker(int argc, VALUE *argv, VALUE self) {
  pn_handshaker_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_handshaker_t *)pn_handshaker();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_hash(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5704

SWIGINTERN VALUE
_wrap_pn_hash(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  pn_hash_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_hash", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_hash", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","pn_hash", 3, argv[2] ));
  } 
  arg3 = (float)(val3);
  result = (pn_hash_t *)pn_hash((struct pn_class_t const *)arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_hash_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_hash_del(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5838

SWIGINTERN VALUE
_wrap_pn_hash_del(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  uintptr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_del", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uintptr_t","pn_hash_del", 2, argv[1] ));
  } 
  arg2 = (uintptr_t)(val2);
  pn_hash_del(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_hash_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5806

SWIGINTERN VALUE
_wrap_pn_hash_get(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  uintptr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_get", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uintptr_t","pn_hash_get", 2, argv[1] ));
  } 
  arg2 = (uintptr_t)(val2);
  result = (void *)pn_hash_get(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_hash_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5867

SWIGINTERN VALUE
_wrap_pn_hash_head(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handle_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_head", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  result = (pn_handle_t)pn_hash_head(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_hash_key(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5923

SWIGINTERN VALUE
_wrap_pn_hash_key(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  uintptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_key", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_hash_key", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (uintptr_t)pn_hash_key(arg1,(void const *)arg2);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_hash_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5891

SWIGINTERN VALUE
_wrap_pn_hash_next(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  pn_handle_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_next", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_hash_next", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (pn_handle_t)pn_hash_next(arg1,(void const *)arg2);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_hash_put(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5768

SWIGINTERN VALUE
_wrap_pn_hash_put(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  uintptr_t arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_put", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uintptr_t","pn_hash_put", 2, argv[1] ));
  } 
  arg2 = (uintptr_t)(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_hash_put", 3, argv[2] )); 
  }
  result = (int)pn_hash_put(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_hash_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5744

SWIGINTERN VALUE
_wrap_pn_hash_size(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_size", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  result = (size_t)pn_hash_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_hash_value(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5955

SWIGINTERN VALUE
_wrap_pn_hash_value(int argc, VALUE *argv, VALUE self) {
  pn_hash_t *arg1 = (pn_hash_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_hash_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_hash_t *","pn_hash_value", 1, argv[0] )); 
  }
  arg1 = (pn_hash_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_hash_value", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (void *)pn_hash_value(arg1,(void const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_hashcode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4936

SWIGINTERN VALUE
_wrap_pn_hashcode(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  uintptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_hashcode", 1, argv[0] )); 
  }
  result = (uintptr_t)pn_hashcode(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_incref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4829

SWIGINTERN VALUE
_wrap_pn_incref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_incref", 1, argv[0] )); 
  }
  result = (void *)pn_incref(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_inspect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5014

SWIGINTERN VALUE
_wrap_pn_inspect(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  pn_string_t *arg2 = (pn_string_t *) 0 ;
  int res1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_inspect", 1, argv[0] )); 
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_string_t *","pn_inspect", 2, argv[1] )); 
  }
  arg2 = (pn_string_t *)(argp2);
  result = (int)pn_inspect(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_iohandler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 23083

SWIGINTERN VALUE
_wrap_pn_iohandler(int argc, VALUE *argv, VALUE self) {
  pn_iohandler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_iohandler_t *)pn_iohandler();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_iterator(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6447

SWIGINTERN VALUE
_wrap_pn_iterator(int argc, VALUE *argv, VALUE self) {
  pn_iterator_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_iterator_t *)pn_iterator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_iterator_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6502

SWIGINTERN VALUE
_wrap_pn_iterator_next(int argc, VALUE *argv, VALUE self) {
  pn_iterator_t *arg1 = (pn_iterator_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_iterator_t *","pn_iterator_next", 1, argv[0] )); 
  }
  arg1 = (pn_iterator_t *)(argp1);
  result = (void *)pn_iterator_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_iterator_start(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6463

SWIGINTERN VALUE
_wrap_pn_iterator_start(int argc, VALUE *argv, VALUE self) {
  pn_iterator_t *arg1 = (pn_iterator_t *) 0 ;
  pn_iterator_next_t arg2 = (pn_iterator_next_t) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_iterator_t *","pn_iterator_start", 1, argv[0] )); 
  }
  arg1 = (pn_iterator_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__p_void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "pn_iterator_next_t","pn_iterator_start", 2, argv[1] )); 
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_iterator_start", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (void *)pn_iterator_start(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_advance(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9247

SWIGINTERN VALUE
_wrap_pn_link_advance(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_advance", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_link_advance(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8756

SWIGINTERN VALUE
_wrap_pn_link_attachments(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_record_t *)pn_link_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_available(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9399

SWIGINTERN VALUE
_wrap_pn_link_available(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_available", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (int)pn_link_available(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9077

SWIGINTERN VALUE
_wrap_pn_link_close(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_close", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_link_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8910

SWIGINTERN VALUE
_wrap_pn_link_condition(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_condition", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_condition_t *)pn_link_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_credit(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9273

SWIGINTERN VALUE
_wrap_pn_link_credit(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_credit", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_link_credit(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_current(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9221

SWIGINTERN VALUE
_wrap_pn_link_current(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_current", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_delivery_t *)pn_link_current(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_detach(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9100

SWIGINTERN VALUE
_wrap_pn_link_detach(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_detach", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  pn_link_detach(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_drain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9715

SWIGINTERN VALUE
_wrap_pn_link_drain(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_drain", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_link_drain", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_link_drain(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_drained(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9373

SWIGINTERN VALUE
_wrap_pn_link_drained(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_drained", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_link_drained(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_draining(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9775

SWIGINTERN VALUE
_wrap_pn_link_draining(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_draining", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (bool)pn_link_draining(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8884

SWIGINTERN VALUE
_wrap_pn_link_error(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_error", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_link_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_flow(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9684

SWIGINTERN VALUE
_wrap_pn_link_flow(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_flow", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_link_flow", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_link_flow(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8682

SWIGINTERN VALUE
_wrap_pn_link_free(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_free", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_link_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8705

SWIGINTERN VALUE
_wrap_pn_link_get_context(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (void *)pn_link_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_get_drain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9349

SWIGINTERN VALUE
_wrap_pn_link_get_drain(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_get_drain", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (bool)pn_link_get_drain(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8986

SWIGINTERN VALUE
_wrap_pn_link_head(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  pn_state_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_link_head", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_state_t","pn_link_head", 2, argv[1] ));
  } 
  arg2 = (pn_state_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_link_t *)pn_link_head(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_is_receiver(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8832

SWIGINTERN VALUE
_wrap_pn_link_is_receiver(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_is_receiver", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_link_is_receiver(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_is_sender(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8806

SWIGINTERN VALUE
_wrap_pn_link_is_sender(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_is_sender", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_link_is_sender(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_max_message_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9799

SWIGINTERN VALUE
_wrap_pn_link_max_message_size(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_max_message_size", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (uint64_t)pn_link_max_message_size(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8780

SWIGINTERN VALUE
_wrap_pn_link_name(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_name", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_link_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_link_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9020

SWIGINTERN VALUE
_wrap_pn_link_next(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  pn_state_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_next", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_state_t","pn_link_next", 2, argv[1] ));
  } 
  arg2 = (pn_state_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_link_t *)pn_link_next(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_offered(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9655

SWIGINTERN VALUE
_wrap_pn_link_offered(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_offered", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_link_offered", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  pn_link_offered(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_open(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9054

SWIGINTERN VALUE
_wrap_pn_link_open(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_open", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_link_open(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_queued(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9299

SWIGINTERN VALUE
_wrap_pn_link_queued(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_queued", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_link_queued(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_rcv_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9447

SWIGINTERN VALUE
_wrap_pn_link_rcv_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_rcv_settle_mode_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_rcv_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_rcv_settle_mode_t)pn_link_rcv_settle_mode(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_recv(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 2915

SWIGINTERN VALUE
_wrap_pn_link_recv(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t n2 ;
  char *buff2 = 0 ;
  size_t size2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","wrap_pn_link_recv", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &n2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t *OUTPUT_SIZE)","wrap_pn_link_recv", 2, argv[1] ));
  }
  buff2= (char *)calloc(n2+1, sizeof(char));
  arg2 = (char *)(buff2);
  size2 = (size_t)(n2);
  arg3 = &size2;
  result = (int)wrap_pn_link_recv(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(arg2,*arg3));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_link_remote_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8934

SWIGINTERN VALUE
_wrap_pn_link_remote_condition(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_condition", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_condition_t *)pn_link_remote_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_credit(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9325

SWIGINTERN VALUE
_wrap_pn_link_remote_credit(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_credit", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (int)pn_link_remote_credit(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_max_message_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9852

SWIGINTERN VALUE
_wrap_pn_link_remote_max_message_size(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_max_message_size", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (uint64_t)pn_link_remote_max_message_size(arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_rcv_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9553

SWIGINTERN VALUE
_wrap_pn_link_remote_rcv_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_rcv_settle_mode_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_rcv_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_rcv_settle_mode_t)pn_link_remote_rcv_settle_mode(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_snd_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9529

SWIGINTERN VALUE
_wrap_pn_link_remote_snd_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_snd_settle_mode_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_snd_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_snd_settle_mode_t)pn_link_remote_snd_settle_mode(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_source(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9169

SWIGINTERN VALUE
_wrap_pn_link_remote_source(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_terminus_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_source", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_terminus_t *)pn_link_remote_source(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_remote_target(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9195

SWIGINTERN VALUE
_wrap_pn_link_remote_target(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_terminus_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_remote_target", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_terminus_t *)pn_link_remote_target(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_send(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 2877

SWIGINTERN VALUE
_wrap_pn_link_send(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_send", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, &size2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_link_send", 2, argv[1] ));
  }  
  arg2 = (char *)(buf2);
  arg3 = (size_t)(size2 - 1);
  result = (ssize_t)pn_link_send(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_link_session(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8958

SWIGINTERN VALUE
_wrap_pn_link_session(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_session", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_session_t *)pn_link_session(arg1);
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8729

SWIGINTERN VALUE
_wrap_pn_link_set_context(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_link_set_context", 2, argv[1] )); 
  }
  pn_link_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_set_drain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9746

SWIGINTERN VALUE
_wrap_pn_link_set_drain(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_set_drain", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_link_set_drain", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_link_set_drain(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_set_max_message_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9823

SWIGINTERN VALUE
_wrap_pn_link_set_max_message_size(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_set_max_message_size", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","pn_link_set_max_message_size", 2, argv[1] ));
  } 
  arg2 = (uint64_t)(val2);
  pn_link_set_max_message_size(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_set_rcv_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9500

SWIGINTERN VALUE
_wrap_pn_link_set_rcv_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  pn_rcv_settle_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_set_rcv_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_rcv_settle_mode_t","pn_link_set_rcv_settle_mode", 2, argv[1] ));
  } 
  arg2 = (pn_rcv_settle_mode_t)(val2);
  pn_link_set_rcv_settle_mode(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_set_snd_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9471

SWIGINTERN VALUE
_wrap_pn_link_set_snd_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  pn_snd_settle_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_set_snd_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_snd_settle_mode_t","pn_link_set_snd_settle_mode", 2, argv[1] ));
  } 
  arg2 = (pn_snd_settle_mode_t)(val2);
  pn_link_set_snd_settle_mode(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_link_snd_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9423

SWIGINTERN VALUE
_wrap_pn_link_snd_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_snd_settle_mode_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_snd_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_snd_settle_mode_t)pn_link_snd_settle_mode(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_source(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9121

SWIGINTERN VALUE
_wrap_pn_link_source(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_terminus_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_source", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_terminus_t *)pn_link_source(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_state(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8858

SWIGINTERN VALUE
_wrap_pn_link_state(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_state_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_state", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_state_t)pn_link_state(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_link_target(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9145

SWIGINTERN VALUE
_wrap_pn_link_target(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_terminus_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_target", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  result = (pn_terminus_t *)pn_link_target(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_link_unsettled(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9577

SWIGINTERN VALUE
_wrap_pn_link_unsettled(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_link_unsettled", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_link_unsettled(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_list(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5044

SWIGINTERN VALUE
_wrap_pn_list(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  pn_list_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_list", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_list", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (pn_list_t *)pn_list((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_list_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_list_add(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5167

SWIGINTERN VALUE
_wrap_pn_list_add(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_add", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_list_add", 2, argv[1] )); 
  }
  result = (int)pn_list_add(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_list_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5318

SWIGINTERN VALUE
_wrap_pn_list_clear(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_clear", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  pn_list_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_list_del(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5281

SWIGINTERN VALUE
_wrap_pn_list_del(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_del", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_list_del", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pn_list_del", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  pn_list_del(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

.pn_list_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5100

SWIGINTERN VALUE
_wrap_pn_list_get(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_get", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_list_get", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (void *)pn_list_get(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_list_index(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5221

SWIGINTERN VALUE
_wrap_pn_list_index(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_index", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_list_index", 2, argv[1] )); 
  }
  result = (ssize_t)pn_list_index(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_list_iterator(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5339

SWIGINTERN VALUE
_wrap_pn_list_iterator(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  pn_iterator_t *arg2 = (pn_iterator_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_iterator", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_iterator_t *","pn_list_iterator", 2, argv[1] )); 
  }
  arg2 = (pn_iterator_t *)(argp2);
  pn_list_iterator(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_list_minpop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5395

SWIGINTERN VALUE
_wrap_pn_list_minpop(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_minpop", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  result = (void *)pn_list_minpop(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_list_minpush(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5368

SWIGINTERN VALUE
_wrap_pn_list_minpush(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_minpush", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_list_minpush", 2, argv[1] )); 
  }
  pn_list_minpush(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_list_pop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5197

SWIGINTERN VALUE
_wrap_pn_list_pop(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_pop", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  result = (void *)pn_list_pop(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_list_remove(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5251

SWIGINTERN VALUE
_wrap_pn_list_remove(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_remove", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_list_remove", 2, argv[1] )); 
  }
  result = (bool)pn_list_remove(arg1,arg2);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_list_set(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5132

SWIGINTERN VALUE
_wrap_pn_list_set(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  int arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_set", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_list_set", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_list_set", 3, argv[2] )); 
  }
  pn_list_set(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

.pn_list_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5076

SWIGINTERN VALUE
_wrap_pn_list_size(int argc, VALUE *argv, VALUE self) {
  pn_list_t *arg1 = (pn_list_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_list_t *","pn_list_size", 1, argv[0] )); 
  }
  arg1 = (pn_list_t *)(argp1);
  result = (size_t)pn_list_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_map(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5419

SWIGINTERN VALUE
_wrap_pn_map(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  pn_class_t *arg2 = (pn_class_t *) 0 ;
  size_t arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  pn_map_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_map", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_class_t const *","pn_map", 2, argv[1] )); 
  }
  arg2 = (pn_class_t *)(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_map", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","pn_map", 4, argv[3] ));
  } 
  arg4 = (float)(val4);
  result = (pn_map_t *)pn_map((struct pn_class_t const *)arg1,(struct pn_class_t const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_map_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_map_del(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5557

SWIGINTERN VALUE
_wrap_pn_map_del(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_del", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_map_del", 2, argv[1] )); 
  }
  pn_map_del(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_map_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5527

SWIGINTERN VALUE
_wrap_pn_map_get(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_get", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_map_get", 2, argv[1] )); 
  }
  result = (void *)pn_map_get(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_map_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5584

SWIGINTERN VALUE
_wrap_pn_map_head(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handle_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_head", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  result = (pn_handle_t)pn_map_head(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_map_key(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5640

SWIGINTERN VALUE
_wrap_pn_map_key(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_key", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_map_key", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (void *)pn_map_key(arg1,(void const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_map_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5608

SWIGINTERN VALUE
_wrap_pn_map_next(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  pn_handle_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_next", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_map_next", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (pn_handle_t)pn_map_next(arg1,(void const *)arg2);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_map_put(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5491

SWIGINTERN VALUE
_wrap_pn_map_put(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_put", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_map_put", 2, argv[1] )); 
  }
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_map_put", 3, argv[2] )); 
  }
  result = (int)pn_map_put(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_map_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5467

SWIGINTERN VALUE
_wrap_pn_map_size(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_size", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  result = (size_t)pn_map_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_map_value(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5672

SWIGINTERN VALUE
_wrap_pn_map_value(int argc, VALUE *argv, VALUE self) {
  pn_map_t *arg1 = (pn_map_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_map_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_map_t *","pn_map_value", 1, argv[0] )); 
  }
  arg1 = (pn_map_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_map_value", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (void *)pn_map_value(arg1,(void const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13124

SWIGINTERN VALUE
_wrap_pn_message(int argc, VALUE *argv, VALUE self) {
  pn_message_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_message_t *)pn_message();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_message_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_annotations(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14676

SWIGINTERN VALUE
_wrap_pn_message_annotations(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_annotations", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_annotations(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_body(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14724

SWIGINTERN VALUE
_wrap_pn_message_body(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_body", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_body(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13163

SWIGINTERN VALUE
_wrap_pn_message_clear(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_clear", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_message_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_message_correlation_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14035

SWIGINTERN VALUE
_wrap_pn_message_correlation_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_correlation_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_correlation_id(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_data(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14833

SWIGINTERN VALUE
_wrap_pn_message_data(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_data_t *arg2 = (pn_data_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_data", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_data_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_data_t *","pn_message_data", 2, argv[1] )); 
  }
  arg2 = (pn_data_t *)(argp2);
  result = (int)pn_message_data(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_decode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14748

SWIGINTERN VALUE
_wrap_pn_message_decode(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_decode", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_decode", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_message_decode", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_decode(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_encode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 2836

SWIGINTERN VALUE
_wrap_pn_message_encode(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t n2 ;
  char *buff2 = 0 ;
  size_t size2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_encode", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &n2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t *OUTPUT_SIZE)","pn_message_encode", 2, argv[1] ));
  }
  buff2= (char *)calloc(n2+1, sizeof(char));
  arg2 = (char *)(buff2);
  size2 = (size_t)(n2);
  arg3 = &size2;
  result = (int)pn_message_encode(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(arg2,*arg3));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_message_errno(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13186

SWIGINTERN VALUE
_wrap_pn_message_errno(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_errno", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_errno(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13212

SWIGINTERN VALUE
_wrap_pn_message_error(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_error", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_message_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13140

SWIGINTERN VALUE
_wrap_pn_message_free(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_free", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_message_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_message_get_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13846

SWIGINTERN VALUE
_wrap_pn_message_get_address(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_address", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_address(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_content_encoding(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14283

SWIGINTERN VALUE
_wrap_pn_message_get_content_encoding(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_content_encoding", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_content_encoding(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_content_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14220

SWIGINTERN VALUE
_wrap_pn_message_get_content_type(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_content_type", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_content_type(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_correlation_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14059

SWIGINTERN VALUE
_wrap_pn_message_get_correlation_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_atom_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_correlation_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = pn_message_get_correlation_id(arg1);
  {
    switch((&result)->type)
    {
    case PN_NULL:
      vresult = Qnil;
      break;
      
    case PN_BOOL:
      vresult = (&result)->u.as_bool ? Qtrue : Qfalse;
      break;
      
    case PN_BYTE:
      vresult = INT2NUM((&result)->u.as_byte);
      break;
      
    case PN_UBYTE:
      vresult = UINT2NUM((&result)->u.as_ubyte);
      break;
      
    case PN_SHORT:
      vresult = INT2NUM((&result)->u.as_short);
      break;
      
    case PN_USHORT:
      vresult = UINT2NUM((&result)->u.as_ushort);
      break;
      
    case PN_INT:
      vresult = INT2NUM((&result)->u.as_int);
      break;
      
    case PN_UINT:
      vresult = UINT2NUM((&result)->u.as_uint);
      break;
      
    case PN_LONG:
      vresult = LL2NUM((&result)->u.as_long);
      break;
      
    case PN_ULONG:
      vresult = ULL2NUM((&result)->u.as_ulong);
      break;
      
    case PN_FLOAT:
      vresult = rb_float_new((&result)->u.as_float);
      break;
      
    case PN_DOUBLE:
      vresult = rb_float_new((&result)->u.as_double);
      break;
      
    case PN_STRING:
      vresult = rb_str_new((&result)->u.as_bytes.start, (&result)->u.as_bytes.size);
      break;
      
    default:
      break;
    }
  }
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_creation_time(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14406

SWIGINTERN VALUE
_wrap_pn_message_get_creation_time(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_creation_time", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_timestamp_t)pn_message_get_creation_time(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_delivery_count(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13534

SWIGINTERN VALUE
_wrap_pn_message_get_delivery_count(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_delivery_count", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (uint32_t)pn_message_get_delivery_count(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_expiry_time(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14346

SWIGINTERN VALUE
_wrap_pn_message_get_expiry_time(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_expiry_time", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_timestamp_t)pn_message_get_expiry_time(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_group_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14466

SWIGINTERN VALUE
_wrap_pn_message_get_group_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_group_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_group_id(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_group_sequence(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14529

SWIGINTERN VALUE
_wrap_pn_message_get_group_sequence(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_sequence_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_group_sequence", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_sequence_t)pn_message_get_group_sequence(arg1);
  vresult = SWIG_From_long((long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13618

SWIGINTERN VALUE
_wrap_pn_message_get_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_atom_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = pn_message_get_id(arg1);
  {
    switch((&result)->type)
    {
    case PN_NULL:
      vresult = Qnil;
      break;
      
    case PN_BOOL:
      vresult = (&result)->u.as_bool ? Qtrue : Qfalse;
      break;
      
    case PN_BYTE:
      vresult = INT2NUM((&result)->u.as_byte);
      break;
      
    case PN_UBYTE:
      vresult = UINT2NUM((&result)->u.as_ubyte);
      break;
      
    case PN_SHORT:
      vresult = INT2NUM((&result)->u.as_short);
      break;
      
    case PN_USHORT:
      vresult = UINT2NUM((&result)->u.as_ushort);
      break;
      
    case PN_INT:
      vresult = INT2NUM((&result)->u.as_int);
      break;
      
    case PN_UINT:
      vresult = UINT2NUM((&result)->u.as_uint);
      break;
      
    case PN_LONG:
      vresult = LL2NUM((&result)->u.as_long);
      break;
      
    case PN_ULONG:
      vresult = ULL2NUM((&result)->u.as_ulong);
      break;
      
    case PN_FLOAT:
      vresult = rb_float_new((&result)->u.as_float);
      break;
      
    case PN_DOUBLE:
      vresult = rb_float_new((&result)->u.as_double);
      break;
      
    case PN_STRING:
      vresult = rb_str_new((&result)->u.as_bytes.start, (&result)->u.as_bytes.size);
      break;
      
    default:
      break;
    }
  }
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_priority(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13354

SWIGINTERN VALUE
_wrap_pn_message_get_priority(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint8_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_priority", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (uint8_t)pn_message_get_priority(arg1);
  vresult = SWIG_From_unsigned_SS_char((unsigned char)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_reply_to(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13972

SWIGINTERN VALUE
_wrap_pn_message_get_reply_to(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_reply_to", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_reply_to(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_reply_to_group_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14589

SWIGINTERN VALUE
_wrap_pn_message_get_reply_to_group_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_reply_to_group_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_reply_to_group_id(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_subject(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13909

SWIGINTERN VALUE
_wrap_pn_message_get_subject(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_subject", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_message_get_subject(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_ttl(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13414

SWIGINTERN VALUE
_wrap_pn_message_get_ttl(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_millis_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_ttl", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_millis_t)pn_message_get_ttl(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_get_user_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13779

SWIGINTERN VALUE
_wrap_pn_message_get_user_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_bytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_get_user_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = pn_message_get_user_id(arg1);
  {
    vresult = rb_str_new((&result)->start, (&result)->size);
  }
  return vresult;
fail:
  return Qnil;
}

.pn_message_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13594

SWIGINTERN VALUE
_wrap_pn_message_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_id(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_instructions(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14652

SWIGINTERN VALUE
_wrap_pn_message_instructions(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_instructions", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_instructions(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_is_durable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13294

SWIGINTERN VALUE
_wrap_pn_message_is_durable(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_is_durable", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_message_is_durable(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_is_first_acquirer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13474

SWIGINTERN VALUE
_wrap_pn_message_is_first_acquirer(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_is_first_acquirer", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (bool)pn_message_is_first_acquirer(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_is_inferred(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13238

SWIGINTERN VALUE
_wrap_pn_message_is_inferred(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_is_inferred", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (bool)pn_message_is_inferred(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_properties(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14700

SWIGINTERN VALUE
_wrap_pn_message_properties(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_properties", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  result = (pn_data_t *)pn_message_properties(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_message_send(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14793

SWIGINTERN VALUE
_wrap_pn_message_send(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_link_t *arg2 = (pn_link_t *) 0 ;
  pn_rwbytes_t *arg3 = (pn_rwbytes_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_send", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_link_t *","pn_message_send", 2, argv[1] )); 
  }
  arg2 = (pn_link_t *)(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_rwbytes_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_rwbytes_t *","pn_message_send", 3, argv[2] )); 
  }
  arg3 = (pn_rwbytes_t *)(argp3);
  result = (ssize_t)pn_message_send(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13872

SWIGINTERN VALUE
_wrap_pn_message_set_address(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_address", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_address", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_address(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_content_encoding(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14309

SWIGINTERN VALUE
_wrap_pn_message_set_content_encoding(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_content_encoding", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_content_encoding", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_content_encoding(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_content_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14246

SWIGINTERN VALUE
_wrap_pn_message_set_content_type(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_content_type", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_content_type", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_content_type(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_correlation_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14143

SWIGINTERN VALUE
_wrap_pn_message_set_correlation_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_atom_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_correlation_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  {
    if (argv[1] == Qnil)
    {
      (&arg2)->type = PN_NULL;
    }
    else
    {
      switch(TYPE(argv[1]))
      {
      case T_TRUE:
        (&arg2)->type = PN_BOOL;
        (&arg2)->u.as_bool = true;
        break;
        
      case T_FALSE:
        (&arg2)->type = PN_BOOL;
        (&arg2)->u.as_bool = false;
        break;
        
      case T_FLOAT:
        (&arg2)->type = PN_FLOAT;
        (&arg2)->u.as_float = NUM2DBL(argv[1]);
        break;
        
      case T_STRING:
        (&arg2)->type = PN_STRING;
        (&arg2)->u.as_bytes.start = RSTRING_PTR(argv[1]);
        if ((&arg2)->u.as_bytes.start)
        {
          (&arg2)->u.as_bytes.size = RSTRING_LEN(argv[1]);
        }
        else
        {
          (&arg2)->u.as_bytes.size = 0;
        }
        break;
        
      case T_FIXNUM:
        (&arg2)->type = PN_INT;
        (&arg2)->u.as_int = FIX2LONG(argv[1]);
        break;
        
      case T_BIGNUM:
        (&arg2)->type = PN_LONG;
        (&arg2)->u.as_long = NUM2LL(argv[1]);
        break;
        
      }
    }
  }
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_correlation_id(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_creation_time(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14432

SWIGINTERN VALUE
_wrap_pn_message_set_creation_time(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_creation_time", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_message_set_creation_time", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_creation_time(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_delivery_count(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13560

SWIGINTERN VALUE
_wrap_pn_message_set_delivery_count(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_delivery_count", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint32_t","pn_message_set_delivery_count", 2, argv[1] ));
  } 
  arg2 = (uint32_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_delivery_count(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_durable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13320

SWIGINTERN VALUE
_wrap_pn_message_set_durable(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_durable", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_message_set_durable", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_durable(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_expiry_time(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14372

SWIGINTERN VALUE
_wrap_pn_message_set_expiry_time(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_expiry_time", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_message_set_expiry_time", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_expiry_time(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_first_acquirer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13500

SWIGINTERN VALUE
_wrap_pn_message_set_first_acquirer(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_first_acquirer", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_message_set_first_acquirer", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_first_acquirer(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_group_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14492

SWIGINTERN VALUE
_wrap_pn_message_set_group_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_group_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_group_id", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_group_id(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_group_sequence(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14555

SWIGINTERN VALUE
_wrap_pn_message_set_group_sequence(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_sequence_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_group_sequence", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_sequence_t","pn_message_set_group_sequence", 2, argv[1] ));
  } 
  arg2 = (pn_sequence_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_group_sequence(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13702

SWIGINTERN VALUE
_wrap_pn_message_set_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_atom_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  {
    if (argv[1] == Qnil)
    {
      (&arg2)->type = PN_NULL;
    }
    else
    {
      switch(TYPE(argv[1]))
      {
      case T_TRUE:
        (&arg2)->type = PN_BOOL;
        (&arg2)->u.as_bool = true;
        break;
        
      case T_FALSE:
        (&arg2)->type = PN_BOOL;
        (&arg2)->u.as_bool = false;
        break;
        
      case T_FLOAT:
        (&arg2)->type = PN_FLOAT;
        (&arg2)->u.as_float = NUM2DBL(argv[1]);
        break;
        
      case T_STRING:
        (&arg2)->type = PN_STRING;
        (&arg2)->u.as_bytes.start = RSTRING_PTR(argv[1]);
        if ((&arg2)->u.as_bytes.start)
        {
          (&arg2)->u.as_bytes.size = RSTRING_LEN(argv[1]);
        }
        else
        {
          (&arg2)->u.as_bytes.size = 0;
        }
        break;
        
      case T_FIXNUM:
        (&arg2)->type = PN_INT;
        (&arg2)->u.as_int = FIX2LONG(argv[1]);
        break;
        
      case T_BIGNUM:
        (&arg2)->type = PN_LONG;
        (&arg2)->u.as_long = NUM2LL(argv[1]);
        break;
        
      }
    }
  }
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_id(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_inferred(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13262

SWIGINTERN VALUE
_wrap_pn_message_set_inferred(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_inferred", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_message_set_inferred", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  result = (int)pn_message_set_inferred(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_priority(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13380

SWIGINTERN VALUE
_wrap_pn_message_set_priority(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  uint8_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_priority", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint8_t","pn_message_set_priority", 2, argv[1] ));
  } 
  arg2 = (uint8_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_priority(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_reply_to(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13998

SWIGINTERN VALUE
_wrap_pn_message_set_reply_to(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_reply_to", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_reply_to", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_reply_to(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_reply_to_group_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14615

SWIGINTERN VALUE
_wrap_pn_message_set_reply_to_group_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_reply_to_group_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_reply_to_group_id", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_reply_to_group_id(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_subject(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13935

SWIGINTERN VALUE
_wrap_pn_message_set_subject(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_subject", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_message_set_subject", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_subject(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_message_set_ttl(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13440

SWIGINTERN VALUE
_wrap_pn_message_set_ttl(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_millis_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_ttl", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_millis_t","pn_message_set_ttl", 2, argv[1] ));
  } 
  arg2 = (pn_millis_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_ttl(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_message_set_user_id(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 13807

SWIGINTERN VALUE
_wrap_pn_message_set_user_id(int argc, VALUE *argv, VALUE self) {
  pn_message_t *arg1 = (pn_message_t *) 0 ;
  pn_bytes_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_message_t *","pn_message_set_user_id", 1, argv[0] )); 
  }
  arg1 = (pn_message_t *)(argp1);
  {
    if (argv[1] == Qnil) {
      (&arg2)->start = NULL;
      (&arg2)->size = 0;
    } else {
      (&arg2)->start = RSTRING_PTR(argv[1]);
      if (!(&arg2)->start) {
        (&arg2)->size = 0;
      }
      (&arg2)->size = RSTRING_LEN(argv[1]);
    }
  }
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_message_set_user_id(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15163

SWIGINTERN VALUE
_wrap_pn_messenger(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  pn_messenger_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","pn_messenger", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  result = (pn_messenger_t *)pn_messenger((char const *)arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.pn_messenger_accept(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16411

SWIGINTERN VALUE
_wrap_pn_messenger_accept(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_accept", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_accept", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pn_messenger_accept", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  result = (int)pn_messenger_accept(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_buffered(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16185

SWIGINTERN VALUE
_wrap_pn_messenger_buffered(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_buffered", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_buffered", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  result = (bool)pn_messenger_buffered(arg1,arg2);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_deadline(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16695

SWIGINTERN VALUE
_wrap_pn_messenger_deadline(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_deadline", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (pn_timestamp_t)pn_messenger_deadline(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_delivery(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16153

SWIGINTERN VALUE
_wrap_pn_messenger_delivery(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_delivery", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_delivery", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  result = (pn_delivery_t *)pn_messenger_delivery(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_errno(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15649

SWIGINTERN VALUE
_wrap_pn_messenger_errno(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_errno", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_errno(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15675

SWIGINTERN VALUE
_wrap_pn_messenger_error(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_error", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_messenger_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15626

SWIGINTERN VALUE
_wrap_pn_messenger_free(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_free", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_messenger_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_messenger_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16329

SWIGINTERN VALUE
_wrap_pn_messenger_get(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_message_t *arg2 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_message_t *","pn_messenger_get", 2, argv[1] )); 
  }
  arg2 = (pn_message_t *)(argp2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_get(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_certificate(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15253

SWIGINTERN VALUE
_wrap_pn_messenger_get_certificate(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_certificate", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (char *)pn_messenger_get_certificate(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_flags(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16751

SWIGINTERN VALUE
_wrap_pn_messenger_get_flags(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_flags", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (int)pn_messenger_get_flags(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_incoming_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15757

SWIGINTERN VALUE
_wrap_pn_messenger_get_incoming_window(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_incoming_window", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (int)pn_messenger_get_incoming_window(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_link(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15969

SWIGINTERN VALUE
_wrap_pn_messenger_get_link(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_link", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_get_link", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","pn_messenger_get_link", 3, argv[2] ));
  } 
  arg3 = (bool)(val3);
  result = (pn_link_t *)pn_messenger_get_link(arg1,(char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_get_outgoing_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15701

SWIGINTERN VALUE
_wrap_pn_messenger_get_outgoing_window(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_outgoing_window", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (int)pn_messenger_get_outgoing_window(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_password(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15371

SWIGINTERN VALUE
_wrap_pn_messenger_get_password(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_password", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (char *)pn_messenger_get_password(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_private_key(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15312

SWIGINTERN VALUE
_wrap_pn_messenger_get_private_key(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_private_key", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (char *)pn_messenger_get_private_key(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_remote_idle_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16867

SWIGINTERN VALUE
_wrap_pn_messenger_get_remote_idle_timeout(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_millis_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_remote_idle_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_get_remote_idle_timeout", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (pn_millis_t)pn_messenger_get_remote_idle_timeout(arg1,(char const *)arg2);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_get_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15488

SWIGINTERN VALUE
_wrap_pn_messenger_get_timeout(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_get_timeout(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_get_trusted_certificates(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15430

SWIGINTERN VALUE
_wrap_pn_messenger_get_trusted_certificates(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_get_trusted_certificates", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (char *)pn_messenger_get_trusted_certificates(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_incoming(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16551

SWIGINTERN VALUE
_wrap_pn_messenger_incoming(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_incoming", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_incoming(arg1);
  SWIG_contract_assert((result>=0), "Contract violation: ensure: (result>=0)");
  
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_incoming_subscription(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16387

SWIGINTERN VALUE
_wrap_pn_messenger_incoming_subscription(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_subscription_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_incoming_subscription", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (pn_subscription_t *)pn_messenger_incoming_subscription(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_incoming_tracker(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16363

SWIGINTERN VALUE
_wrap_pn_messenger_incoming_tracker(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_tracker_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_incoming_tracker", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (pn_tracker_t)pn_messenger_incoming_tracker(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_interrupt(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16281

SWIGINTERN VALUE
_wrap_pn_messenger_interrupt(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_interrupt", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (int)pn_messenger_interrupt(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_is_blocking(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15514

SWIGINTERN VALUE
_wrap_pn_messenger_is_blocking(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_is_blocking", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (bool)pn_messenger_is_blocking(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_is_passive(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15570

SWIGINTERN VALUE
_wrap_pn_messenger_is_passive(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_is_passive", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (bool)pn_messenger_is_passive(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15190

SWIGINTERN VALUE
_wrap_pn_messenger_name(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_name", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (char *)pn_messenger_name(arg1);
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_outgoing(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16523

SWIGINTERN VALUE
_wrap_pn_messenger_outgoing(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_outgoing", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_outgoing(arg1);
  SWIG_contract_assert((result>=0), "Contract violation: ensure: (result>=0)");
  
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_outgoing_tracker(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16257

SWIGINTERN VALUE
_wrap_pn_messenger_outgoing_tracker(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_tracker_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_outgoing_tracker", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (pn_tracker_t)pn_messenger_outgoing_tracker(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_put(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16087

SWIGINTERN VALUE
_wrap_pn_messenger_put(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_message_t *arg2 = (pn_message_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_put", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_message_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_message_t *","pn_messenger_put", 2, argv[1] )); 
  }
  arg2 = (pn_message_t *)(argp2);
  SWIG_contract_assert((arg1!=NULL)&&(arg2!=NULL), "Contract violation: require: (arg1!=NULL)&&(arg2!=NULL)");
  
  result = (int)pn_messenger_put(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_receiving(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16305

SWIGINTERN VALUE
_wrap_pn_messenger_receiving(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_receiving", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (int)pn_messenger_receiving(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_recv(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3255

SWIGINTERN VALUE
_wrap_pn_messenger_recv(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","wrap_pn_messenger_recv", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","wrap_pn_messenger_recv", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)wrap_pn_messenger_recv(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_reject(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16451

SWIGINTERN VALUE
_wrap_pn_messenger_reject(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_reject", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_reject", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pn_messenger_reject", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  result = (int)pn_messenger_reject(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_rewrite(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16625

SWIGINTERN VALUE
_wrap_pn_messenger_rewrite(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_rewrite", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_rewrite", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_messenger_rewrite", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (int)pn_messenger_rewrite(arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_messenger_route(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16579

SWIGINTERN VALUE
_wrap_pn_messenger_route(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_route", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_route", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_messenger_route", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (int)pn_messenger_route(arg1,(char const *)arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_messenger_selectable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16671

SWIGINTERN VALUE
_wrap_pn_messenger_selectable(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_selectable_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_selectable", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (pn_selectable_t *)pn_messenger_selectable(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_send(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3223

SWIGINTERN VALUE
_wrap_pn_messenger_send(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","wrap_pn_messenger_send", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","wrap_pn_messenger_send", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)wrap_pn_messenger_send(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_blocking(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15538

SWIGINTERN VALUE
_wrap_pn_messenger_set_blocking(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_blocking", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_messenger_set_blocking", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  result = (int)pn_messenger_set_blocking(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_certificate(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15218

SWIGINTERN VALUE
_wrap_pn_messenger_set_certificate(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_certificate", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_set_certificate", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_messenger_set_certificate(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_set_flags(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16719

SWIGINTERN VALUE
_wrap_pn_messenger_set_flags(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_flags", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_messenger_set_flags", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)pn_messenger_set_flags(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_incoming_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15781

SWIGINTERN VALUE
_wrap_pn_messenger_set_incoming_window(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_incoming_window", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_messenger_set_incoming_window", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)pn_messenger_set_incoming_window(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_outgoing_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15725

SWIGINTERN VALUE
_wrap_pn_messenger_set_outgoing_window(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_outgoing_window", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_messenger_set_outgoing_window", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)pn_messenger_set_outgoing_window(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_passive(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15594

SWIGINTERN VALUE
_wrap_pn_messenger_set_passive(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_passive", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_messenger_set_passive", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  result = (int)pn_messenger_set_passive(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_password(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15336

SWIGINTERN VALUE
_wrap_pn_messenger_set_password(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_password", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_set_password", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_messenger_set_password(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_set_private_key(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15277

SWIGINTERN VALUE
_wrap_pn_messenger_set_private_key(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_private_key", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_set_private_key", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_messenger_set_private_key(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_set_rcv_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16807

SWIGINTERN VALUE
_wrap_pn_messenger_set_rcv_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_rcv_settle_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_rcv_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_rcv_settle_mode_t","pn_messenger_set_rcv_settle_mode", 2, argv[1] ));
  } 
  arg2 = (pn_rcv_settle_mode_t)(val2);
  result = (int)pn_messenger_set_rcv_settle_mode(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_snd_settle_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16775

SWIGINTERN VALUE
_wrap_pn_messenger_set_snd_settle_mode(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_snd_settle_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_snd_settle_mode", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_snd_settle_mode_t","pn_messenger_set_snd_settle_mode", 2, argv[1] ));
  } 
  arg2 = (pn_snd_settle_mode_t)(val2);
  result = (int)pn_messenger_set_snd_settle_mode(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_ssl_peer_authentication_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16902

SWIGINTERN VALUE
_wrap_pn_messenger_set_ssl_peer_authentication_mode(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_ssl_verify_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_ssl_peer_authentication_mode", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_ssl_verify_mode_t","pn_messenger_set_ssl_peer_authentication_mode", 2, argv[1] ));
  } 
  arg2 = (pn_ssl_verify_mode_t)(val2);
  result = (int)pn_messenger_set_ssl_peer_authentication_mode(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15454

SWIGINTERN VALUE
_wrap_pn_messenger_set_timeout(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_messenger_set_timeout", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_set_timeout(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_set_tracer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16839

SWIGINTERN VALUE
_wrap_pn_messenger_set_tracer(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracer_t arg2 = (pn_tracer_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_tracer", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_transport_t_p_q_const__char__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "pn_tracer_t","pn_messenger_set_tracer", 2, argv[1] )); 
    }
  }
  pn_messenger_set_tracer(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_messenger_set_trusted_certificates(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15395

SWIGINTERN VALUE
_wrap_pn_messenger_set_trusted_certificates(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_set_trusted_certificates", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_set_trusted_certificates", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_messenger_set_trusted_certificates(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_settle(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16217

SWIGINTERN VALUE
_wrap_pn_messenger_settle(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_settle", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_settle", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","pn_messenger_settle", 3, argv[2] ));
  } 
  arg3 = (int)(val3);
  result = (int)pn_messenger_settle(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_start(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15813

SWIGINTERN VALUE
_wrap_pn_messenger_start(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_start", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_start(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_status(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16121

SWIGINTERN VALUE
_wrap_pn_messenger_status(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  pn_status_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_status", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_status", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  result = (pn_status_t)pn_messenger_status(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_stop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15839

SWIGINTERN VALUE
_wrap_pn_messenger_stop(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_stop", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (int)pn_messenger_stop(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_stopped(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15865

SWIGINTERN VALUE
_wrap_pn_messenger_stopped(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_stopped", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  result = (bool)pn_messenger_stopped(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_subscribe(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15889

SWIGINTERN VALUE
_wrap_pn_messenger_subscribe(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_subscription_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_subscribe", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_subscribe", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL)&&(arg2!=NULL), "Contract violation: require: (arg1!=NULL)&&(arg2!=NULL)");
  
  result = (pn_subscription_t *)pn_messenger_subscribe(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_subscribe_ttl(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15926

SWIGINTERN VALUE
_wrap_pn_messenger_subscribe_ttl(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  char *arg2 = (char *) 0 ;
  pn_seconds_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  pn_subscription_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_subscribe_ttl", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_messenger_subscribe_ttl", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "pn_seconds_t","pn_messenger_subscribe_ttl", 3, argv[2] ));
  } 
  arg3 = (pn_seconds_t)(val3);
  result = (pn_subscription_t *)pn_messenger_subscribe_ttl(arg1,(char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_messenger_tracker_link(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16491

SWIGINTERN VALUE
_wrap_pn_messenger_tracker_link(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  pn_tracker_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","pn_messenger_tracker_link", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_tracker_t","pn_messenger_tracker_link", 2, argv[1] ));
  } 
  arg2 = (pn_tracker_t)(val2);
  result = (pn_link_t *)pn_messenger_tracker_link(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_messenger_work(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3287

SWIGINTERN VALUE
_wrap_pn_messenger_work(int argc, VALUE *argv, VALUE self) {
  pn_messenger_t *arg1 = (pn_messenger_t *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_messenger_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_messenger_t *","wrap_pn_messenger_work", 1, argv[0] )); 
  }
  arg1 = (pn_messenger_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","wrap_pn_messenger_work", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  result = (int)wrap_pn_messenger_work(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.PN_OBJECT ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4130

SWIGINTERN VALUE
_wrap_PN_OBJECT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(PN_OBJECT), SWIGTYPE_p_pn_class_t,  0 );
  return _val;
}

.pn_object_decref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4791

SWIGINTERN VALUE
_wrap_pn_object_decref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_decref", 1, argv[0] )); 
  }
  pn_object_decref(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_object_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4810

SWIGINTERN VALUE
_wrap_pn_object_free(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_free", 1, argv[0] )); 
  }
  pn_object_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_object_incref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4750

SWIGINTERN VALUE
_wrap_pn_object_incref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_incref", 1, argv[0] )); 
  }
  pn_object_incref(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_object_new(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4696

SWIGINTERN VALUE
_wrap_pn_object_new(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_object_new", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_object_new", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (void *)pn_object_new((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_object_reactor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22944

SWIGINTERN VALUE
_wrap_pn_object_reactor(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_reactor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_reactor", 1, argv[0] )); 
  }
  result = (pn_reactor_t *)pn_object_reactor(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_object_refcount(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4769

SWIGINTERN VALUE
_wrap_pn_object_refcount(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_refcount", 1, argv[0] )); 
  }
  result = (int)pn_object_refcount(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_object_reify(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4728

SWIGINTERN VALUE
_wrap_pn_object_reify(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  pn_class_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_object_reify", 1, argv[0] )); 
  }
  result = (pn_class_t *)pn_object_reify(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_class_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_rb2void(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3558

SWIGINTERN VALUE
_wrap_pn_rb2void(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (void *)pn_rb2void(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_rbhandler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3872

SWIGINTERN VALUE
_wrap_pn_rbhandler(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (pn_handler_t *)pn_rbhandler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey__class(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3319

SWIGINTERN VALUE
_wrap_Pn_rbkey__class(int argc, VALUE *argv, VALUE self) {
  pn_class_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_class_t *)Pn_rbkey__class();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_class_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey_get_key_value(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3490

SWIGINTERN VALUE
_wrap_Pn_rbkey_get_key_value(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_get_key_value", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  result = (char *)Pn_rbkey_get_key_value(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey_get_method(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3434

SWIGINTERN VALUE
_wrap_Pn_rbkey_get_method(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_get_method", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  result = (char *)Pn_rbkey_get_method(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey_get_registry(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3378

SWIGINTERN VALUE
_wrap_Pn_rbkey_get_registry(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_get_registry", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  result = (void *)Pn_rbkey_get_registry(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey_new(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3335

SWIGINTERN VALUE
_wrap_Pn_rbkey_new(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Pn_rbkey_t *)Pn_rbkey_new();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.Pn_rbkey_set_key_value(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3458

SWIGINTERN VALUE
_wrap_Pn_rbkey_set_key_value(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_set_key_value", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","Pn_rbkey_set_key_value", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  Pn_rbkey_set_key_value(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.Pn_rbkey_set_method(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3402

SWIGINTERN VALUE
_wrap_Pn_rbkey_set_method(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_set_method", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","Pn_rbkey_set_method", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  Pn_rbkey_set_method(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.Pn_rbkey_set_registry(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3351

SWIGINTERN VALUE
_wrap_Pn_rbkey_set_registry(int argc, VALUE *argv, VALUE self) {
  Pn_rbkey_t *arg1 = (Pn_rbkey_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Pn_rbkey_t *","Pn_rbkey_set_registry", 1, argv[0] )); 
  }
  arg1 = (Pn_rbkey_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","Pn_rbkey_set_registry", 2, argv[1] )); 
  }
  Pn_rbkey_set_registry(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21850

SWIGINTERN VALUE
_wrap_pn_reactor(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_reactor_t *)pn_reactor();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_acceptor(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22240

SWIGINTERN VALUE
_wrap_pn_reactor_acceptor(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  pn_handler_t *arg4 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  pn_acceptor_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_acceptor", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_reactor_acceptor", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_reactor_acceptor", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_acceptor", 4, argv[3] )); 
  }
  arg4 = (pn_handler_t *)(argp4);
  result = (pn_acceptor_t *)pn_reactor_acceptor(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_acceptor_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_reactor_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21866

SWIGINTERN VALUE
_wrap_pn_reactor_attachments(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_record_t *)pn_reactor_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_children(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22163

SWIGINTERN VALUE
_wrap_pn_reactor_children(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_list_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_children", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_list_t *)pn_reactor_children(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_list_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_collector(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22033

SWIGINTERN VALUE
_wrap_pn_reactor_collector(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_collector_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_collector", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_collector_t *)pn_reactor_collector(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_collector_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22372

SWIGINTERN VALUE
_wrap_pn_reactor_connection(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_handler_t *arg2 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_connection", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_connection", 2, argv[1] )); 
  }
  arg2 = (pn_handler_t *)(argp2);
  result = (pn_connection_t *)pn_reactor_connection(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_connection_to_host(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22318

SWIGINTERN VALUE
_wrap_pn_reactor_connection_to_host(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  pn_handler_t *arg4 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_connection_to_host", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_reactor_connection_to_host", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_reactor_connection_to_host", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_connection_to_host", 4, argv[3] )); 
  }
  arg4 = (pn_handler_t *)(argp4);
  result = (pn_connection_t *)pn_reactor_connection_to_host(arg1,(char const *)arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_reactor_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22294

SWIGINTERN VALUE
_wrap_pn_reactor_error(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_error", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_error_t *)pn_reactor_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22012

SWIGINTERN VALUE
_wrap_pn_reactor_free(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_free", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  pn_reactor_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_get_connection_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22455

SWIGINTERN VALUE
_wrap_pn_reactor_get_connection_address(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_connection_t *arg2 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_get_connection_address", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_connection_t *","pn_reactor_get_connection_address", 2, argv[1] )); 
  }
  arg2 = (pn_connection_t *)(argp2);
  result = (char *)pn_reactor_get_connection_address(arg1,arg2);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_get_global_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22057

SWIGINTERN VALUE
_wrap_pn_reactor_get_global_handler(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_get_global_handler", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_handler_t *)pn_reactor_get_global_handler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_get_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22110

SWIGINTERN VALUE
_wrap_pn_reactor_get_handler(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_get_handler", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_handler_t *)pn_reactor_get_handler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_get_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21890

SWIGINTERN VALUE
_wrap_pn_reactor_get_timeout(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_millis_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_get_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_millis_t)pn_reactor_get_timeout(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_mark(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21943

SWIGINTERN VALUE
_wrap_pn_reactor_mark(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_mark", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_timestamp_t)pn_reactor_mark(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_now(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21967

SWIGINTERN VALUE
_wrap_pn_reactor_now(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_now", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_timestamp_t)pn_reactor_now(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_process(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22556

SWIGINTERN VALUE
_wrap_pn_reactor_process(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_process", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (bool)pn_reactor_process(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_quiesced(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22532

SWIGINTERN VALUE
_wrap_pn_reactor_quiesced(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_quiesced", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (bool)pn_reactor_quiesced(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_run(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22601

SWIGINTERN VALUE
_wrap_pn_reactor_run(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_run", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  pn_reactor_run(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_schedule(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22622

SWIGINTERN VALUE
_wrap_pn_reactor_schedule(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  int arg2 ;
  pn_handler_t *arg3 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  pn_task_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_schedule", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","pn_reactor_schedule", 2, argv[1] ));
  } 
  arg2 = (int)(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_schedule", 3, argv[2] )); 
  }
  arg3 = (pn_handler_t *)(argp3);
  result = (pn_task_t *)pn_reactor_schedule(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_task_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_selectable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22187

SWIGINTERN VALUE
_wrap_pn_reactor_selectable(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_selectable_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_selectable", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (pn_selectable_t *)pn_reactor_selectable(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_set_connection_host(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22404

SWIGINTERN VALUE
_wrap_pn_reactor_set_connection_host(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_connection_t *arg2 = (pn_connection_t *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_set_connection_host", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_connection_t *","pn_reactor_set_connection_host", 2, argv[1] )); 
  }
  arg2 = (pn_connection_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_reactor_set_connection_host", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","pn_reactor_set_connection_host", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  pn_reactor_set_connection_host(arg1,arg2,(char const *)arg3,(char const *)arg4);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

.pn_reactor_set_global_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22081

SWIGINTERN VALUE
_wrap_pn_reactor_set_global_handler(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_handler_t *arg2 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_set_global_handler", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_set_global_handler", 2, argv[1] )); 
  }
  arg2 = (pn_handler_t *)(argp2);
  pn_reactor_set_global_handler(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_set_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22134

SWIGINTERN VALUE
_wrap_pn_reactor_set_handler(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_handler_t *arg2 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_set_handler", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_handler_t *","pn_reactor_set_handler", 2, argv[1] )); 
  }
  arg2 = (pn_handler_t *)(argp2);
  pn_reactor_set_handler(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_set_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21914

SWIGINTERN VALUE
_wrap_pn_reactor_set_timeout(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_millis_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_set_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_millis_t","pn_reactor_set_timeout", 2, argv[1] ));
  } 
  arg2 = (pn_millis_t)(val2);
  pn_reactor_set_timeout(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_start(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22511

SWIGINTERN VALUE
_wrap_pn_reactor_start(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_start", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  pn_reactor_start(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_stop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22580

SWIGINTERN VALUE
_wrap_pn_reactor_stop(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_stop", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  pn_reactor_stop(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_update(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22211

SWIGINTERN VALUE
_wrap_pn_reactor_update(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  pn_selectable_t *arg2 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_update", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_reactor_update", 2, argv[1] )); 
  }
  arg2 = (pn_selectable_t *)(argp2);
  pn_reactor_update(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_reactor_wakeup(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22487

SWIGINTERN VALUE
_wrap_pn_reactor_wakeup(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_wakeup", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  result = (int)pn_reactor_wakeup(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_reactor_yield(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21991

SWIGINTERN VALUE
_wrap_pn_reactor_yield(int argc, VALUE *argv, VALUE self) {
  pn_reactor_t *arg1 = (pn_reactor_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_reactor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_reactor_t *","pn_reactor_yield", 1, argv[0] )); 
  }
  arg1 = (pn_reactor_t *)(argp1);
  pn_reactor_yield(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_receiver(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8643

SWIGINTERN VALUE
_wrap_pn_receiver(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_receiver", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_receiver", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_link_t *)pn_receiver(arg1,(char const *)arg2);
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_record(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6526

SWIGINTERN VALUE
_wrap_pn_record(int argc, VALUE *argv, VALUE self) {
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_record_t *)pn_record();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_record_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6678

SWIGINTERN VALUE
_wrap_pn_record_clear(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_clear", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  pn_record_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_record_def(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6542

SWIGINTERN VALUE
_wrap_pn_record_def(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  pn_class_t *arg3 = (pn_class_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_def", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_record_def", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "pn_class_t const *","pn_record_def", 3, argv[2] )); 
  }
  arg3 = (pn_class_t *)(argp3);
  pn_record_def(arg1,(void const *)arg2,(struct pn_class_t const *)arg3);
  return Qnil;
fail:
  return Qnil;
}

.pn_record_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6611

SWIGINTERN VALUE
_wrap_pn_record_get(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_get", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_record_get", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (void *)pn_record_get(arg1,(void const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_record_get_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22990

SWIGINTERN VALUE
_wrap_pn_record_get_handler(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_handler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_get_handler", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  result = (pn_handler_t *)pn_record_get_handler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_handler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_record_has(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6579

SWIGINTERN VALUE
_wrap_pn_record_has(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_has", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_record_has", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  result = (bool)pn_record_has(arg1,(void const *)arg2);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_record_set(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6643

SWIGINTERN VALUE
_wrap_pn_record_set(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  pn_handle_t arg2 = (pn_handle_t) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int res3 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_set", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_handle_t","pn_record_set", 2, argv[1] ));
  } 
  arg2 = (pn_handle_t)(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","pn_record_set", 3, argv[2] )); 
  }
  pn_record_set(arg1,(void const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

.pn_record_set_handler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 23014

SWIGINTERN VALUE
_wrap_pn_record_set_handler(int argc, VALUE *argv, VALUE self) {
  pn_record_t *arg1 = (pn_record_t *) 0 ;
  pn_handler_t *arg2 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_record_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_record_t *","pn_record_set_handler", 1, argv[0] )); 
  }
  arg1 = (pn_record_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_handler_t *","pn_record_set_handler", 2, argv[1] )); 
  }
  arg2 = (pn_handler_t *)(argp2);
  pn_record_set_handler(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_refcount(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4873

SWIGINTERN VALUE
_wrap_pn_refcount(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_refcount", 1, argv[0] )); 
  }
  result = (int)pn_refcount(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_rwbytes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4086

SWIGINTERN VALUE
_wrap_pn_rwbytes(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_rwbytes_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","pn_rwbytes", 1, argv[0] ));
  } 
  arg1 = (size_t)(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_rwbytes", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = pn_rwbytes(arg1,arg2);
  vresult = SWIG_NewPointerObj((pn_rwbytes_t *)memcpy((pn_rwbytes_t *)calloc(1,sizeof(pn_rwbytes_t)),&result,sizeof(pn_rwbytes_t)), SWIGTYPE_p_pn_rwbytes_t, SWIG_POINTER_OWN |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_rwbytes_null ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4121

SWIGINTERN VALUE
_wrap_pn_rwbytes_null_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&pn_rwbytes_null), SWIGTYPE_p_pn_rwbytes_t,  0 );
  return _val;
}

.pn_sasl(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14865

SWIGINTERN VALUE
_wrap_pn_sasl(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_sasl_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_sasl", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_sasl_t *)pn_sasl(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_allowed_mechs(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15012

SWIGINTERN VALUE
_wrap_pn_sasl_allowed_mechs(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_allowed_mechs", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_sasl_allowed_mechs", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_sasl_allowed_mechs(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_sasl_config_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15099

SWIGINTERN VALUE
_wrap_pn_sasl_config_name(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_config_name", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_sasl_config_name", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_sasl_config_name(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_sasl_config_path(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15131

SWIGINTERN VALUE
_wrap_pn_sasl_config_path(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_config_path", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_sasl_config_path", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_sasl_config_path(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_sasl_done(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14905

SWIGINTERN VALUE
_wrap_pn_sasl_done(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  pn_sasl_outcome_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_done", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_sasl_outcome_t","pn_sasl_done", 2, argv[1] ));
  } 
  arg2 = (pn_sasl_outcome_t)(val2);
  SWIG_contract_assert((arg1!=NULL)&&(check_sasl_outcome(arg2)), "Contract violation: require: (arg1!=NULL)&&(check_sasl_outcome(arg2))");
  
  pn_sasl_done(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_sasl_extended(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14889

SWIGINTERN VALUE
_wrap_pn_sasl_extended(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (bool)pn_sasl_extended();
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_get_allow_insecure_mechs(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15075

SWIGINTERN VALUE
_wrap_pn_sasl_get_allow_insecure_mechs(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_get_allow_insecure_mechs", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  result = (bool)pn_sasl_get_allow_insecure_mechs(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_get_mech(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14988

SWIGINTERN VALUE
_wrap_pn_sasl_get_mech(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_get_mech", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  result = (char *)pn_sasl_get_mech(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_get_user(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14964

SWIGINTERN VALUE
_wrap_pn_sasl_get_user(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_get_user", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  result = (char *)pn_sasl_get_user(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_outcome(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 14936

SWIGINTERN VALUE
_wrap_pn_sasl_outcome(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_sasl_outcome_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_outcome", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_sasl_outcome_t)pn_sasl_outcome(arg1);
  SWIG_contract_assert((check_sasl_outcome(result)), "Contract violation: ensure: (check_sasl_outcome(result))");
  
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_sasl_set_allow_insecure_mechs(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 15046

SWIGINTERN VALUE
_wrap_pn_sasl_set_allow_insecure_mechs(int argc, VALUE *argv, VALUE self) {
  pn_sasl_t *arg1 = (pn_sasl_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_sasl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_sasl_t *","pn_sasl_set_allow_insecure_mechs", 1, argv[0] )); 
  }
  arg1 = (pn_sasl_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_sasl_set_allow_insecure_mechs", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_sasl_set_allow_insecure_mechs(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16995

SWIGINTERN VALUE
_wrap_pn_selectable(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_selectable_t *)pn_selectable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17179

SWIGINTERN VALUE
_wrap_pn_selectable_attachments(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (pn_record_t *)pn_selectable_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_collect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17639

SWIGINTERN VALUE
_wrap_pn_selectable_collect(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  pn_collector_t *arg2 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_collect", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_collector_t *","pn_selectable_collect", 2, argv[1] )); 
  }
  arg2 = (pn_collector_t *)(argp2);
  pn_selectable_collect(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17457

SWIGINTERN VALUE
_wrap_pn_selectable_error(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_error", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_error(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_expired(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17478

SWIGINTERN VALUE
_wrap_pn_selectable_expired(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_expired", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_expired(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17618

SWIGINTERN VALUE
_wrap_pn_selectable_free(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_free", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_get_deadline(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17362

SWIGINTERN VALUE
_wrap_pn_selectable_get_deadline(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_get_deadline", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (pn_timestamp_t)pn_selectable_get_deadline(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_get_fd(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17203

SWIGINTERN VALUE
_wrap_pn_selectable_get_fd(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_socket_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_get_fd", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (pn_socket_t)pn_selectable_get_fd(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_is_reading(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17256

SWIGINTERN VALUE
_wrap_pn_selectable_is_reading(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_is_reading", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (bool)pn_selectable_is_reading(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_is_registered(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17499

SWIGINTERN VALUE
_wrap_pn_selectable_is_registered(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_is_registered", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (bool)pn_selectable_is_registered(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_is_terminal(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17552

SWIGINTERN VALUE
_wrap_pn_selectable_is_terminal(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_is_terminal", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (bool)pn_selectable_is_terminal(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_is_writing(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17309

SWIGINTERN VALUE
_wrap_pn_selectable_is_writing(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_is_writing", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  result = (bool)pn_selectable_is_writing(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_selectable_on_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17095

SWIGINTERN VALUE
_wrap_pn_selectable_on_error(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_error", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_error", 2, argv[1] )); 
    }
  }
  pn_selectable_on_error(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_on_expired(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17067

SWIGINTERN VALUE
_wrap_pn_selectable_on_expired(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_expired", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_expired", 2, argv[1] )); 
    }
  }
  pn_selectable_on_expired(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_on_finalize(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17151

SWIGINTERN VALUE
_wrap_pn_selectable_on_finalize(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_finalize", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_finalize", 2, argv[1] )); 
    }
  }
  pn_selectable_on_finalize(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_on_readable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17011

SWIGINTERN VALUE
_wrap_pn_selectable_on_readable(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_readable", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_readable", 2, argv[1] )); 
    }
  }
  pn_selectable_on_readable(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_on_release(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17123

SWIGINTERN VALUE
_wrap_pn_selectable_on_release(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_release", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_release", 2, argv[1] )); 
    }
  }
  pn_selectable_on_release(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_on_writable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17039

SWIGINTERN VALUE
_wrap_pn_selectable_on_writable(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  void (*arg2)(pn_selectable_t *) = (void (*)(pn_selectable_t *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_on_writable", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_selectable_t__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "void (*)(pn_selectable_t *)","pn_selectable_on_writable", 2, argv[1] )); 
    }
  }
  pn_selectable_on_writable(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_readable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17415

SWIGINTERN VALUE
_wrap_pn_selectable_readable(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_readable", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_readable(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_release(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17597

SWIGINTERN VALUE
_wrap_pn_selectable_release(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_release", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_release(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_set_deadline(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17386

SWIGINTERN VALUE
_wrap_pn_selectable_set_deadline(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_set_deadline", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_selectable_set_deadline", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  pn_selectable_set_deadline(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_set_fd(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17227

SWIGINTERN VALUE
_wrap_pn_selectable_set_fd(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  pn_socket_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_set_fd", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_socket_t","pn_selectable_set_fd", 2, argv[1] ));
  } 
  arg2 = (pn_socket_t)(val2);
  pn_selectable_set_fd(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_set_reading(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17280

SWIGINTERN VALUE
_wrap_pn_selectable_set_reading(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_set_reading", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_selectable_set_reading", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_selectable_set_reading(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_set_registered(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17523

SWIGINTERN VALUE
_wrap_pn_selectable_set_registered(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_set_registered", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_selectable_set_registered", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_selectable_set_registered(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_set_writing(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17333

SWIGINTERN VALUE
_wrap_pn_selectable_set_writing(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_set_writing", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_selectable_set_writing", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_selectable_set_writing(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_terminate(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17576

SWIGINTERN VALUE
_wrap_pn_selectable_terminate(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_terminate", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_terminate(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectable_writable(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17436

SWIGINTERN VALUE
_wrap_pn_selectable_writable(int argc, VALUE *argv, VALUE self) {
  pn_selectable_t *arg1 = (pn_selectable_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectable_t *","pn_selectable_writable", 1, argv[0] )); 
  }
  arg1 = (pn_selectable_t *)(argp1);
  pn_selectable_writable(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectables(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16934

SWIGINTERN VALUE
_wrap_pn_selectables(int argc, VALUE *argv, VALUE self) {
  pn_selectables_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_selectables_t *)pn_selectables();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_selectables_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16974

SWIGINTERN VALUE
_wrap_pn_selectables_free(int argc, VALUE *argv, VALUE self) {
  pn_selectables_t *arg1 = (pn_selectables_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectables_t *","pn_selectables_free", 1, argv[0] )); 
  }
  arg1 = (pn_selectables_t *)(argp1);
  pn_selectables_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_selectables_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16950

SWIGINTERN VALUE
_wrap_pn_selectables_next(int argc, VALUE *argv, VALUE self) {
  pn_selectables_t *arg1 = (pn_selectables_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_selectable_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_iterator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_selectables_t *","pn_selectables_next", 1, argv[0] )); 
  }
  arg1 = (pn_selectables_t *)(argp1);
  result = (pn_selectable_t *)pn_selectables_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_selectable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_sender(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8604

SWIGINTERN VALUE
_wrap_pn_sender(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  pn_link_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_sender", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_sender", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_link_t *)pn_sender(arg1,(char const *)arg2);
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_session(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8084

SWIGINTERN VALUE
_wrap_pn_session(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_session", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_session_t *)pn_session(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8184

SWIGINTERN VALUE
_wrap_pn_session_attachments(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (pn_record_t *)pn_session_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_close(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8359

SWIGINTERN VALUE
_wrap_pn_session_close(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_close", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_session_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8260

SWIGINTERN VALUE
_wrap_pn_session_condition(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_condition", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (pn_condition_t *)pn_session_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8308

SWIGINTERN VALUE
_wrap_pn_session_connection(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_connection", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_connection_t *)pn_session_connection(arg1);
  SWIG_contract_assert((result!=NULL), "Contract violation: ensure: (result!=NULL)");
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8234

SWIGINTERN VALUE
_wrap_pn_session_error(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_error", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_session_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8110

SWIGINTERN VALUE
_wrap_pn_session_free(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_free", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_session_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8133

SWIGINTERN VALUE
_wrap_pn_session_get_context(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (void *)pn_session_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_get_incoming_capacity(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8382

SWIGINTERN VALUE
_wrap_pn_session_get_incoming_capacity(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_get_incoming_capacity", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (size_t)pn_session_get_incoming_capacity(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_session_get_outgoing_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8435

SWIGINTERN VALUE
_wrap_pn_session_get_outgoing_window(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_get_outgoing_window", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (size_t)pn_session_get_outgoing_window(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_session_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8536

SWIGINTERN VALUE
_wrap_pn_session_head(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  pn_state_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_session_head", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_state_t","pn_session_head", 2, argv[1] ));
  } 
  arg2 = (pn_state_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_session_t *)pn_session_head(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_incoming_bytes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8512

SWIGINTERN VALUE
_wrap_pn_session_incoming_bytes(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_incoming_bytes", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (size_t)pn_session_incoming_bytes(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_session_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8570

SWIGINTERN VALUE
_wrap_pn_session_next(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  pn_state_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  pn_session_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_next", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_state_t","pn_session_next", 2, argv[1] ));
  } 
  arg2 = (pn_state_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_session_t *)pn_session_next(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_session_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_open(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8336

SWIGINTERN VALUE
_wrap_pn_session_open(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_open", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_session_open(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_outgoing_bytes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8488

SWIGINTERN VALUE
_wrap_pn_session_outgoing_bytes(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_outgoing_bytes", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (size_t)pn_session_outgoing_bytes(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_session_remote_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8284

SWIGINTERN VALUE
_wrap_pn_session_remote_condition(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_remote_condition", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  result = (pn_condition_t *)pn_session_remote_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_session_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8157

SWIGINTERN VALUE
_wrap_pn_session_set_context(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_session_set_context", 2, argv[1] )); 
  }
  pn_session_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_set_incoming_capacity(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8406

SWIGINTERN VALUE
_wrap_pn_session_set_incoming_capacity(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_set_incoming_capacity", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_session_set_incoming_capacity", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  pn_session_set_incoming_capacity(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_set_outgoing_window(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8459

SWIGINTERN VALUE
_wrap_pn_session_set_outgoing_window(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_set_outgoing_window", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_session_set_outgoing_window", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  pn_session_set_outgoing_window(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_session_state(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 8208

SWIGINTERN VALUE
_wrap_pn_session_state(int argc, VALUE *argv, VALUE self) {
  pn_session_t *arg1 = (pn_session_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_state_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_session_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_session_t *","pn_session_state", 1, argv[0] )); 
  }
  arg1 = (pn_session_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_state_t)pn_session_state(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_ssl(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17958

SWIGINTERN VALUE
_wrap_pn_ssl(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_ssl_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_ssl", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_ssl_t *)pn_ssl(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_domain(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17684

SWIGINTERN VALUE
_wrap_pn_ssl_domain(int argc, VALUE *argv, VALUE self) {
  pn_ssl_mode_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  pn_ssl_domain_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "pn_ssl_mode_t","pn_ssl_domain", 1, argv[0] ));
  } 
  arg1 = (pn_ssl_mode_t)(val1);
  result = (pn_ssl_domain_t *)pn_ssl_domain(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_domain_allow_unsecured_client(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17934

SWIGINTERN VALUE
_wrap_pn_ssl_domain_allow_unsecured_client(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_allow_unsecured_client", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  result = (int)pn_ssl_domain_allow_unsecured_client(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_domain_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17708

SWIGINTERN VALUE
_wrap_pn_ssl_domain_free(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_free", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  pn_ssl_domain_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_ssl_domain_set_ciphers(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17899

SWIGINTERN VALUE
_wrap_pn_ssl_domain_set_ciphers(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_set_ciphers", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_ciphers", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_ssl_domain_set_ciphers(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_ssl_domain_set_credentials(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17729

SWIGINTERN VALUE
_wrap_pn_ssl_domain_set_credentials(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_set_credentials", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_credentials", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_credentials", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_credentials", 4, argv[3] ));
  }
  arg4 = (char *)(buf4);
  result = (int)pn_ssl_domain_set_credentials(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
  return Qnil;
}

.pn_ssl_domain_set_peer_authentication(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17821

SWIGINTERN VALUE
_wrap_pn_ssl_domain_set_peer_authentication(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  pn_ssl_verify_mode_t arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_set_peer_authentication", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_ssl_verify_mode_t","pn_ssl_domain_set_peer_authentication", 2, argv[1] ));
  } 
  arg2 = (pn_ssl_verify_mode_t)(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_peer_authentication", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (int)pn_ssl_domain_set_peer_authentication(arg1,arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_ssl_domain_set_protocols(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17864

SWIGINTERN VALUE
_wrap_pn_ssl_domain_set_protocols(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_set_protocols", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_protocols", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_ssl_domain_set_protocols(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_ssl_domain_set_trusted_ca_db(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17786

SWIGINTERN VALUE
_wrap_pn_ssl_domain_set_trusted_ca_db(int argc, VALUE *argv, VALUE self) {
  pn_ssl_domain_t *arg1 = (pn_ssl_domain_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_domain_set_trusted_ca_db", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_domain_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_ssl_domain_set_trusted_ca_db", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_ssl_domain_set_trusted_ca_db(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_ssl_get_cert_fingerprint(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18132

SWIGINTERN VALUE
_wrap_pn_ssl_get_cert_fingerprint(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  pn_ssl_hash_alg arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_cert_fingerprint", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_ssl_get_cert_fingerprint", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_ssl_get_cert_fingerprint", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "pn_ssl_hash_alg","pn_ssl_get_cert_fingerprint", 4, argv[3] ));
  } 
  arg4 = (pn_ssl_hash_alg)(val4);
  result = (int)pn_ssl_get_cert_fingerprint(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_ssl_get_cipher_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3145

SWIGINTERN VALUE
_wrap_pn_ssl_get_cipher_name(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t size2 ;
  char *buff2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_cipher_name", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &size2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t MAX_OUTPUT_SIZE)","pn_ssl_get_cipher_name", 2, argv[1] ));
  }
  buff2= (char *)calloc(size2+1, sizeof(char));
  arg3 = (size_t)(size2);
  arg2 = (char *)(buff2);
  result = (bool)pn_ssl_get_cipher_name(arg1,arg2,arg3);
  vresult = SWIG_From_bool((bool)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtr(arg2));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_ssl_get_peer_hostname(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3598

SWIGINTERN VALUE
_wrap_pn_ssl_get_peer_hostname(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t n2 ;
  char *buff2 = 0 ;
  size_t size2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_peer_hostname", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &n2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t *OUTPUT_SIZE)","pn_ssl_get_peer_hostname", 2, argv[1] ));
  }
  buff2= (char *)calloc(n2+1, sizeof(char));
  arg2 = (char *)(buff2);
  size2 = (size_t)(n2);
  arg3 = &size2;
  result = (int)pn_ssl_get_peer_hostname(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(arg2,*arg3));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_ssl_get_protocol_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3184

SWIGINTERN VALUE
_wrap_pn_ssl_get_protocol_name(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t size2 ;
  char *buff2 = 0 ;
  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(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_protocol_name", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &size2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t MAX_OUTPUT_SIZE)","pn_ssl_get_protocol_name", 2, argv[1] ));
  }
  buff2= (char *)calloc(size2+1, sizeof(char));
  arg3 = (size_t)(size2);
  arg2 = (char *)(buff2);
  result = (bool)pn_ssl_get_protocol_name(arg1,arg2,arg3);
  vresult = SWIG_From_bool((bool)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtr(arg2));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_ssl_get_remote_subject(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18108

SWIGINTERN VALUE
_wrap_pn_ssl_get_remote_subject(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_remote_subject", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  result = (char *)pn_ssl_get_remote_subject(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_get_remote_subject_subfield(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18183

SWIGINTERN VALUE
_wrap_pn_ssl_get_remote_subject_subfield(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  pn_ssl_cert_subject_subfield arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_remote_subject_subfield", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_ssl_cert_subject_subfield","pn_ssl_get_remote_subject_subfield", 2, argv[1] ));
  } 
  arg2 = (pn_ssl_cert_subject_subfield)(val2);
  result = (char *)pn_ssl_get_remote_subject_subfield(arg1,arg2);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_get_ssf(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18025

SWIGINTERN VALUE
_wrap_pn_ssl_get_ssf(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_get_ssf", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  result = (int)pn_ssl_get_ssf(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_init(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17982

SWIGINTERN VALUE
_wrap_pn_ssl_init(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  pn_ssl_domain_t *arg2 = (pn_ssl_domain_t *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_init", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_ssl_domain_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_ssl_domain_t *","pn_ssl_init", 2, argv[1] )); 
  }
  arg2 = (pn_ssl_domain_t *)(argp2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pn_ssl_init", 3, argv[2] ));
  }
  arg3 = (char *)(buf3);
  result = (int)pn_ssl_init(arg1,arg2,(char const *)arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
  return Qnil;
}

.pn_ssl_present(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 17668

SWIGINTERN VALUE
_wrap_pn_ssl_present(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (bool)pn_ssl_present();
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_resume_status(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18049

SWIGINTERN VALUE
_wrap_pn_ssl_resume_status(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_ssl_resume_status_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_resume_status", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  result = (pn_ssl_resume_status_t)pn_ssl_resume_status(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_ssl_set_peer_hostname(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18073

SWIGINTERN VALUE
_wrap_pn_ssl_set_peer_hostname(int argc, VALUE *argv, VALUE self) {
  pn_ssl_t *arg1 = (pn_ssl_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_ssl_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_ssl_t *","pn_ssl_set_peer_hostname", 1, argv[0] )); 
  }
  arg1 = (pn_ssl_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_ssl_set_peer_hostname", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_ssl_set_peer_hostname(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 5987

SWIGINTERN VALUE
_wrap_pn_string(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  pn_string_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","pn_string", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  result = (pn_string_t *)pn_string((char const *)arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.pn_string_addf(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6267

SWIGINTERN VALUE
_wrap_pn_string_addf(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if (argc < 2) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_addf", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_string_addf", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_string_addf(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string_buffer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6335

SWIGINTERN VALUE
_wrap_pn_string_buffer(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_buffer", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  result = (char *)pn_string_buffer(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_string_capacity(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6359

SWIGINTERN VALUE
_wrap_pn_string_capacity(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_capacity", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  result = (size_t)pn_string_capacity(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_string_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6210

SWIGINTERN VALUE
_wrap_pn_string_clear(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_clear", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  pn_string_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_string_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6415

SWIGINTERN VALUE
_wrap_pn_string_copy(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  pn_string_t *arg2 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_copy", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_copy", 2, argv[1] )); 
  }
  arg2 = (pn_string_t *)(argp2);
  result = (int)pn_string_copy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_string_format(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6231

SWIGINTERN VALUE
_wrap_pn_string_format(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if (argc < 2) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_format", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_string_format", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_string_format(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string_get(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6049

SWIGINTERN VALUE
_wrap_pn_string_get(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_get", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  result = (char *)pn_string_get(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_string_grow(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6303

SWIGINTERN VALUE
_wrap_pn_string_grow(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_grow", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_string_grow", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (int)pn_string_grow(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_string_put(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6175

SWIGINTERN VALUE
_wrap_pn_string_put(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_put", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_string_put", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (ssize_t)pn_string_put(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string_resize(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6383

SWIGINTERN VALUE
_wrap_pn_string_resize(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_resize", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_string_resize", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (int)pn_string_resize(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_string_set(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6097

SWIGINTERN VALUE
_wrap_pn_string_set(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_set", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_string_set", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_string_set(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string_setn(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6132

SWIGINTERN VALUE
_wrap_pn_string_setn(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_setn", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_string_setn", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_string_setn", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (int)pn_string_setn(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_string_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6073

SWIGINTERN VALUE
_wrap_pn_string_size(int argc, VALUE *argv, VALUE self) {
  pn_string_t *arg1 = (pn_string_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_string_t *","pn_string_size", 1, argv[0] )); 
  }
  arg1 = (pn_string_t *)(argp1);
  result = (size_t)pn_string_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_stringn(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 6014

SWIGINTERN VALUE
_wrap_pn_stringn(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  size_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  pn_string_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","pn_stringn", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_stringn", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (pn_string_t *)pn_stringn((char const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.pn_subscription_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16063

SWIGINTERN VALUE
_wrap_pn_subscription_address(int argc, VALUE *argv, VALUE self) {
  pn_subscription_t *arg1 = (pn_subscription_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_subscription_t *","pn_subscription_address", 1, argv[0] )); 
  }
  arg1 = (pn_subscription_t *)(argp1);
  result = (char *)pn_subscription_address(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_subscription_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16012

SWIGINTERN VALUE
_wrap_pn_subscription_get_context(int argc, VALUE *argv, VALUE self) {
  pn_subscription_t *arg1 = (pn_subscription_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_subscription_t *","pn_subscription_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_subscription_t *)(argp1);
  result = (void *)pn_subscription_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_subscription_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 16036

SWIGINTERN VALUE
_wrap_pn_subscription_set_context(int argc, VALUE *argv, VALUE self) {
  pn_subscription_t *arg1 = (pn_subscription_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_subscription_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_subscription_t *","pn_subscription_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_subscription_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_subscription_set_context", 2, argv[1] )); 
  }
  pn_subscription_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_task_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22869

SWIGINTERN VALUE
_wrap_pn_task_attachments(int argc, VALUE *argv, VALUE self) {
  pn_task_t *arg1 = (pn_task_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_task_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_task_t *","pn_task_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_task_t *)(argp1);
  result = (pn_record_t *)pn_task_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_task_cancel(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22893

SWIGINTERN VALUE
_wrap_pn_task_cancel(int argc, VALUE *argv, VALUE self) {
  pn_task_t *arg1 = (pn_task_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_task_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_task_t *","pn_task_cancel", 1, argv[0] )); 
  }
  arg1 = (pn_task_t *)(argp1);
  pn_task_cancel(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_terminus_capabilities(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10295

SWIGINTERN VALUE
_wrap_pn_terminus_capabilities(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_capabilities", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_data_t *)pn_terminus_capabilities(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10367

SWIGINTERN VALUE
_wrap_pn_terminus_copy(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_terminus_t *arg2 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_copy", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_copy", 2, argv[1] )); 
  }
  arg2 = (pn_terminus_t *)(argp2);
  result = (int)pn_terminus_copy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_filter(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10343

SWIGINTERN VALUE
_wrap_pn_terminus_filter(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_filter", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_data_t *)pn_terminus_filter(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9932

SWIGINTERN VALUE
_wrap_pn_terminus_get_address(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_get_address", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (char *)pn_terminus_get_address(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_distribution_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9991

SWIGINTERN VALUE
_wrap_pn_terminus_get_distribution_mode(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_distribution_mode_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t const *","pn_terminus_get_distribution_mode", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_distribution_mode_t)pn_terminus_get_distribution_mode((struct pn_terminus_t const *)arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_durability(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10047

SWIGINTERN VALUE
_wrap_pn_terminus_get_durability(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_durability_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_get_durability", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_durability_t)pn_terminus_get_durability(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_expiry_policy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10103

SWIGINTERN VALUE
_wrap_pn_terminus_get_expiry_policy(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_expiry_policy_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_get_expiry_policy", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_expiry_policy_t)pn_terminus_get_expiry_policy(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10159

SWIGINTERN VALUE
_wrap_pn_terminus_get_timeout(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_seconds_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_get_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_seconds_t)pn_terminus_get_timeout(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_get_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9876

SWIGINTERN VALUE
_wrap_pn_terminus_get_type(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_terminus_type_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_get_type", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_terminus_type_t)pn_terminus_get_type(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_is_dynamic(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10215

SWIGINTERN VALUE
_wrap_pn_terminus_is_dynamic(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_is_dynamic", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (bool)pn_terminus_is_dynamic(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_outcomes(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10319

SWIGINTERN VALUE
_wrap_pn_terminus_outcomes(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_outcomes", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_data_t *)pn_terminus_outcomes(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_properties(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10271

SWIGINTERN VALUE
_wrap_pn_terminus_properties(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_data_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_properties", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  result = (pn_data_t *)pn_terminus_properties(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_data_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_address(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9956

SWIGINTERN VALUE
_wrap_pn_terminus_set_address(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_address", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_terminus_set_address", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  result = (int)pn_terminus_set_address(arg1,(char const *)arg2);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_terminus_set_distribution_mode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10015

SWIGINTERN VALUE
_wrap_pn_terminus_set_distribution_mode(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_distribution_mode_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_distribution_mode", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_distribution_mode_t","pn_terminus_set_distribution_mode", 2, argv[1] ));
  } 
  arg2 = (pn_distribution_mode_t)(val2);
  result = (int)pn_terminus_set_distribution_mode(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_durability(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10071

SWIGINTERN VALUE
_wrap_pn_terminus_set_durability(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_durability_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_durability", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_durability_t","pn_terminus_set_durability", 2, argv[1] ));
  } 
  arg2 = (pn_durability_t)(val2);
  result = (int)pn_terminus_set_durability(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_dynamic(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10239

SWIGINTERN VALUE
_wrap_pn_terminus_set_dynamic(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_dynamic", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_terminus_set_dynamic", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  result = (int)pn_terminus_set_dynamic(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_expiry_policy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10127

SWIGINTERN VALUE
_wrap_pn_terminus_set_expiry_policy(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_expiry_policy_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_expiry_policy", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_expiry_policy_t","pn_terminus_set_expiry_policy", 2, argv[1] ));
  } 
  arg2 = (pn_expiry_policy_t)(val2);
  result = (int)pn_terminus_set_expiry_policy(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10183

SWIGINTERN VALUE
_wrap_pn_terminus_set_timeout(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_seconds_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_seconds_t","pn_terminus_set_timeout", 2, argv[1] ));
  } 
  arg2 = (pn_seconds_t)(val2);
  result = (int)pn_terminus_set_timeout(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_terminus_set_type(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9900

SWIGINTERN VALUE
_wrap_pn_terminus_set_type(int argc, VALUE *argv, VALUE self) {
  pn_terminus_t *arg1 = (pn_terminus_t *) 0 ;
  pn_terminus_type_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_terminus_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_terminus_t *","pn_terminus_set_type", 1, argv[0] )); 
  }
  arg1 = (pn_terminus_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_terminus_type_t","pn_terminus_set_type", 2, argv[1] ));
  } 
  arg2 = (pn_terminus_type_t)(val2);
  result = (int)pn_terminus_set_type(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_timer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22736

SWIGINTERN VALUE
_wrap_pn_timer(int argc, VALUE *argv, VALUE self) {
  pn_collector_t *arg1 = (pn_collector_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timer_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_collector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_collector_t *","pn_timer", 1, argv[0] )); 
  }
  arg1 = (pn_collector_t *)(argp1);
  result = (pn_timer_t *)pn_timer(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_timer_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_timer_deadline(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22760

SWIGINTERN VALUE
_wrap_pn_timer_deadline(int argc, VALUE *argv, VALUE self) {
  pn_timer_t *arg1 = (pn_timer_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_timer_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_timer_t *","pn_timer_deadline", 1, argv[0] )); 
  }
  arg1 = (pn_timer_t *)(argp1);
  result = (pn_timestamp_t)pn_timer_deadline(arg1);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_timer_schedule(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22813

SWIGINTERN VALUE
_wrap_pn_timer_schedule(int argc, VALUE *argv, VALUE self) {
  pn_timer_t *arg1 = (pn_timer_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  pn_task_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_timer_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_timer_t *","pn_timer_schedule", 1, argv[0] )); 
  }
  arg1 = (pn_timer_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_timer_schedule", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  result = (pn_task_t *)pn_timer_schedule(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_task_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_timer_tasks(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22845

SWIGINTERN VALUE
_wrap_pn_timer_tasks(int argc, VALUE *argv, VALUE self) {
  pn_timer_t *arg1 = (pn_timer_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_timer_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_timer_t *","pn_timer_tasks", 1, argv[0] )); 
  }
  arg1 = (pn_timer_t *)(argp1);
  result = (int)pn_timer_tasks(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_timer_tick(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 22784

SWIGINTERN VALUE
_wrap_pn_timer_tick(int argc, VALUE *argv, VALUE self) {
  pn_timer_t *arg1 = (pn_timer_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_timer_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_timer_t *","pn_timer_tick", 1, argv[0] )); 
  }
  arg1 = (pn_timer_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_timer_tick", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  pn_timer_tick(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11366

SWIGINTERN VALUE
_wrap_pn_transport(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_transport_t *)pn_transport();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_transport_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_attachments(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11796

SWIGINTERN VALUE
_wrap_pn_transport_attachments(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_record_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_attachments", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_record_t *)pn_transport_attachments(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_record_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_bind(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11606

SWIGINTERN VALUE
_wrap_pn_transport_bind(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  pn_connection_t *arg2 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_bind", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_connection_t *","pn_transport_bind", 2, argv[1] )); 
  }
  arg2 = (pn_connection_t *)(argp2);
  result = (int)pn_transport_bind(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_capacity(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12119

SWIGINTERN VALUE
_wrap_pn_transport_capacity(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_capacity", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (ssize_t)pn_transport_capacity(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_close_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12343

SWIGINTERN VALUE
_wrap_pn_transport_close_head(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_close_head", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (int)pn_transport_close_head(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_close_tail(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12242

SWIGINTERN VALUE
_wrap_pn_transport_close_tail(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_close_tail", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (int)pn_transport_close_tail(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_closed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12439

SWIGINTERN VALUE
_wrap_pn_transport_closed(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_closed", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_closed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_condition(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11556

SWIGINTERN VALUE
_wrap_pn_transport_condition(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_condition_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_condition", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_condition_t *)pn_transport_condition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_condition_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12543

SWIGINTERN VALUE
_wrap_pn_transport_connection(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_connection", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_connection_t *)pn_transport_connection(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_error(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11580

SWIGINTERN VALUE
_wrap_pn_transport_error(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_error_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_error", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_error_t *)pn_transport_error(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_error_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11403

SWIGINTERN VALUE
_wrap_pn_transport_free(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_free", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_transport_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_get_channel_max(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11885

SWIGINTERN VALUE
_wrap_pn_transport_get_channel_max(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint16_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_channel_max", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint16_t)pn_transport_get_channel_max(arg1);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11745

SWIGINTERN VALUE
_wrap_pn_transport_get_context(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_context", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (void *)pn_transport_get_context(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_frames_input(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12519

SWIGINTERN VALUE
_wrap_pn_transport_get_frames_input(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t const *","pn_transport_get_frames_input", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint64_t)pn_transport_get_frames_input((struct pn_transport_t const *)arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_frames_output(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12495

SWIGINTERN VALUE
_wrap_pn_transport_get_frames_output(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t const *","pn_transport_get_frames_output", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint64_t)pn_transport_get_frames_output((struct pn_transport_t const *)arg1);
  vresult = SWIG_From_unsigned_SS_long_SS_long((unsigned long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_idle_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12042

SWIGINTERN VALUE
_wrap_pn_transport_get_idle_timeout(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_millis_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_idle_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_millis_t)pn_transport_get_idle_timeout(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_max_frame(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11965

SWIGINTERN VALUE
_wrap_pn_transport_get_max_frame(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_max_frame", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint32_t)pn_transport_get_max_frame(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_remote_idle_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12095

SWIGINTERN VALUE
_wrap_pn_transport_get_remote_idle_timeout(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_millis_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_remote_idle_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_millis_t)pn_transport_get_remote_idle_timeout(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_remote_max_frame(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12018

SWIGINTERN VALUE
_wrap_pn_transport_get_remote_max_frame(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint32_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_remote_max_frame", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint32_t)pn_transport_get_remote_max_frame(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_tracer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11721

SWIGINTERN VALUE
_wrap_pn_transport_get_tracer(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_tracer_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_tracer", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (pn_tracer_t)pn_transport_get_tracer(arg1);
  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_pn_transport_t_p_q_const__char__void);
  return vresult;
fail:
  return Qnil;
}

.pn_transport_get_user(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11426

SWIGINTERN VALUE
_wrap_pn_transport_get_user(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_get_user", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (char *)pn_transport_get_user(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_transport_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12290

SWIGINTERN VALUE
_wrap_pn_transport_head(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_head", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (char *)pn_transport_head(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_transport_head_closed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12391

SWIGINTERN VALUE
_wrap_pn_transport_head_closed(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_head_closed", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_head_closed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_input(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 2956

SWIGINTERN VALUE
_wrap_pn_transport_input(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_input", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, &size2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pn_transport_input", 2, argv[1] ));
  }  
  arg2 = (char *)(buf2);
  arg3 = (size_t)(size2 - 1);
  result = (ssize_t)pn_transport_input(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_transport_is_authenticated(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11479

SWIGINTERN VALUE
_wrap_pn_transport_is_authenticated(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_is_authenticated", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_is_authenticated(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_is_encrypted(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11532

SWIGINTERN VALUE
_wrap_pn_transport_is_encrypted(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_is_encrypted", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_is_encrypted(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_log(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11820

SWIGINTERN VALUE
_wrap_pn_transport_log(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_log", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_transport_log", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_transport_log(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_transport_logf(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11852

SWIGINTERN VALUE
_wrap_pn_transport_logf(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if (argc < 2) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_logf", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_transport_logf", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_transport_logf(arg1,(char const *)arg2,arg3);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_transport_output(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 2994

SWIGINTERN VALUE
_wrap_pn_transport_output(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t n2 ;
  char *buff2 = 0 ;
  size_t size2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","wrap_pn_transport_output", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &n2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t *OUTPUT_SIZE)","wrap_pn_transport_output", 2, argv[1] ));
  }
  buff2= (char *)calloc(n2+1, sizeof(char));
  arg2 = (char *)(buff2);
  size2 = (size_t)(n2);
  arg3 = &size2;
  result = (int)wrap_pn_transport_output(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(arg2,*arg3));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_transport_peek(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3035

SWIGINTERN VALUE
_wrap_pn_transport_peek(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t n2 ;
  char *buff2 = 0 ;
  size_t size2 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","wrap_pn_transport_peek", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsVal_size_t (argv[1], &n2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "(char *OUTPUT, size_t *OUTPUT_SIZE)","wrap_pn_transport_peek", 2, argv[1] ));
  }
  buff2= (char *)calloc(n2+1, sizeof(char));
  arg2 = (char *)(buff2);
  size2 = (size_t)(n2);
  arg3 = &size2;
  result = (int)wrap_pn_transport_peek(arg1,arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  vresult = SWIG_Ruby_AppendOutput(vresult, SWIG_FromCharPtrAndSize(arg2,*arg3));
  if (buff2) free((char*)buff2);
  return vresult;
fail:
  if (buff2) free((char*)buff2);
  return Qnil;
}

.pn_transport_pending(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12266

SWIGINTERN VALUE
_wrap_pn_transport_pending(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_pending", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (ssize_t)pn_transport_pending(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_pop(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12314

SWIGINTERN VALUE
_wrap_pn_transport_pop(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_pop", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_transport_pop", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  pn_transport_pop(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_process(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12210

SWIGINTERN VALUE
_wrap_pn_transport_process(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_process", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_transport_process", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (int)pn_transport_process(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_push(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12167

SWIGINTERN VALUE
_wrap_pn_transport_push(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  ssize_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_push", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_transport_push", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","pn_transport_push", 3, argv[2] ));
  } 
  arg3 = (size_t)(val3);
  result = (ssize_t)pn_transport_push(arg1,(char const *)arg2,arg3);
  vresult = SWIG_From_int((int)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_transport_quiesced(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12367

SWIGINTERN VALUE
_wrap_pn_transport_quiesced(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_quiesced", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_quiesced(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_remote_channel_max(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11941

SWIGINTERN VALUE
_wrap_pn_transport_remote_channel_max(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint16_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_remote_channel_max", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (uint16_t)pn_transport_remote_channel_max(arg1);
  vresult = SWIG_From_unsigned_SS_short((unsigned short)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_require_auth(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11450

SWIGINTERN VALUE
_wrap_pn_transport_require_auth(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_require_auth", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_transport_require_auth", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_transport_require_auth(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_require_encryption(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11503

SWIGINTERN VALUE
_wrap_pn_transport_require_encryption(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_require_encryption", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","pn_transport_require_encryption", 2, argv[1] ));
  } 
  arg2 = (bool)(val2);
  pn_transport_require_encryption(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_set_channel_max(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11909

SWIGINTERN VALUE
_wrap_pn_transport_set_channel_max(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  uint16_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_channel_max", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint16_t","pn_transport_set_channel_max", 2, argv[1] ));
  } 
  arg2 = (uint16_t)(val2);
  result = (int)pn_transport_set_channel_max(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_set_context(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11769

SWIGINTERN VALUE
_wrap_pn_transport_set_context(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_context", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_transport_set_context", 2, argv[1] )); 
  }
  pn_transport_set_context(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_set_idle_timeout(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12066

SWIGINTERN VALUE
_wrap_pn_transport_set_idle_timeout(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  pn_millis_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_idle_timeout", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_millis_t","pn_transport_set_idle_timeout", 2, argv[1] ));
  } 
  arg2 = (pn_millis_t)(val2);
  pn_transport_set_idle_timeout(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_set_max_frame(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11989

SWIGINTERN VALUE
_wrap_pn_transport_set_max_frame(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  uint32_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_max_frame", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint32_t","pn_transport_set_max_frame", 2, argv[1] ));
  } 
  arg2 = (uint32_t)(val2);
  pn_transport_set_max_frame(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_set_server(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11382

SWIGINTERN VALUE
_wrap_pn_transport_set_server(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_server", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  pn_transport_set_server(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_set_tracer(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11693

SWIGINTERN VALUE
_wrap_pn_transport_set_tracer(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  pn_tracer_t arg2 = (pn_tracer_t) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_set_tracer", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg2), SWIGTYPE_p_f_p_struct_pn_transport_t_p_q_const__char__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "pn_tracer_t","pn_transport_set_tracer", 2, argv[1] )); 
    }
  }
  pn_transport_set_tracer(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_tail(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12143

SWIGINTERN VALUE
_wrap_pn_transport_tail(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_tail", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (char *)pn_transport_tail(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_transport_tail_closed(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12415

SWIGINTERN VALUE
_wrap_pn_transport_tail_closed(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_tail_closed", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (bool)pn_transport_tail_closed(arg1);
  vresult = SWIG_From_bool((bool)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_tick(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 12463

SWIGINTERN VALUE
_wrap_pn_transport_tick(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  pn_timestamp_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  pn_timestamp_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_tick", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_timestamp_t","pn_transport_tick", 2, argv[1] ));
  } 
  arg2 = (pn_timestamp_t)(val2);
  result = (pn_timestamp_t)pn_transport_tick(arg1,arg2);
  vresult = SWIG_From_long_SS_long((long long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_transport_trace(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11662

SWIGINTERN VALUE
_wrap_pn_transport_trace(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  pn_trace_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_trace", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "pn_trace_t","pn_transport_trace", 2, argv[1] ));
  } 
  arg2 = (pn_trace_t)(val2);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  pn_transport_trace(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pn_transport_unbind(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11638

SWIGINTERN VALUE
_wrap_pn_transport_unbind(int argc, VALUE *argv, VALUE self) {
  pn_transport_t *arg1 = (pn_transport_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_transport_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_transport_t *","pn_transport_unbind", 1, argv[0] )); 
  }
  arg1 = (pn_transport_t *)(argp1);
  result = (int)pn_transport_unbind(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_type_name(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 18215

SWIGINTERN VALUE
_wrap_pn_type_name(int argc, VALUE *argv, VALUE self) {
  pn_type_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "pn_type_t","pn_type_name", 1, argv[0] ));
  } 
  arg1 = (pn_type_t)(val1);
  result = (char *)pn_type_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_unsettled_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9603

SWIGINTERN VALUE
_wrap_pn_unsettled_head(int argc, VALUE *argv, VALUE self) {
  pn_link_t *arg1 = (pn_link_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_link_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_link_t *","pn_unsettled_head", 1, argv[0] )); 
  }
  arg1 = (pn_link_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_delivery_t *)pn_unsettled_head(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_unsettled_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 9629

SWIGINTERN VALUE
_wrap_pn_unsettled_next(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_unsettled_next", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_delivery_t *)pn_unsettled_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_url(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21212

SWIGINTERN VALUE
_wrap_pn_url(int argc, VALUE *argv, VALUE self) {
  pn_url_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_url_t *)pn_url();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_url_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_url_clear(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21276

SWIGINTERN VALUE
_wrap_pn_url_clear(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_clear", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  pn_url_clear(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_url_free(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21255

SWIGINTERN VALUE
_wrap_pn_url_free(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_free", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  pn_url_free(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_url_get_host(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21393

SWIGINTERN VALUE
_wrap_pn_url_get_host(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_host", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_host(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_get_password(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21369

SWIGINTERN VALUE
_wrap_pn_url_get_password(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_password", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_password(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_get_path(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21441

SWIGINTERN VALUE
_wrap_pn_url_get_path(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_path", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_path(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_get_port(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21417

SWIGINTERN VALUE
_wrap_pn_url_get_port(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_port", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_port(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_get_scheme(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21321

SWIGINTERN VALUE
_wrap_pn_url_get_scheme(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_scheme", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_scheme(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_get_username(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21345

SWIGINTERN VALUE
_wrap_pn_url_get_username(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_get_username", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_get_username(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.pn_url_parse(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21228

SWIGINTERN VALUE
_wrap_pn_url_parse(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  pn_url_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","pn_url_parse", 1, argv[0] ));
  }
  arg1 = (char *)(buf1);
  result = (pn_url_t *)pn_url_parse((char const *)arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
  return Qnil;
}

.pn_url_set_host(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21561

SWIGINTERN VALUE
_wrap_pn_url_set_host(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_host", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_host", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_host(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_set_password(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21529

SWIGINTERN VALUE
_wrap_pn_url_set_password(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_password", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_password", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_password(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_set_path(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21625

SWIGINTERN VALUE
_wrap_pn_url_set_path(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_path", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_path", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_path(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_set_port(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21593

SWIGINTERN VALUE
_wrap_pn_url_set_port(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_port", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_port", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_port(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_set_scheme(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21465

SWIGINTERN VALUE
_wrap_pn_url_set_scheme(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_scheme", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_scheme", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_scheme(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_set_username(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21497

SWIGINTERN VALUE
_wrap_pn_url_set_username(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_set_username", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pn_url_set_username", 2, argv[1] ));
  }
  arg2 = (char *)(buf2);
  pn_url_set_username(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pn_url_str(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 21297

SWIGINTERN VALUE
_wrap_pn_url_str(int argc, VALUE *argv, VALUE self) {
  pn_url_t *arg1 = (pn_url_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_url_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_url_t *","pn_url_str", 1, argv[0] )); 
  }
  arg1 = (pn_url_t *)(argp1);
  result = (char *)pn_url_str(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.PN_VOID ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4139

SWIGINTERN VALUE
_wrap_PN_VOID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(PN_VOID), SWIGTYPE_p_pn_class_t,  0 );
  return _val;
}

.pn_void2rb(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3536

SWIGINTERN VALUE
_wrap_pn_void2rb(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void2rb", 1, argv[0] )); 
  }
  result = (VALUE)pn_void2rb(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

.pn_void_compare(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4638

SWIGINTERN VALUE
_wrap_pn_void_compare(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  int res2 ;
  intptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_compare", 1, argv[0] )); 
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","pn_void_compare", 2, argv[1] )); 
  }
  result = pn_void_compare(arg1,arg2);
  vresult = SWIG_NewPointerObj((intptr_t *)memcpy((intptr_t *)calloc(1,sizeof(intptr_t)),&result,sizeof(intptr_t)), SWIGTYPE_p_intptr_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_void_decref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4575

SWIGINTERN VALUE
_wrap_pn_void_decref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_decref", 1, argv[0] )); 
  }
  pn_void_decref(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_void_hashcode(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4616

SWIGINTERN VALUE
_wrap_pn_void_hashcode(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  uintptr_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_hashcode", 1, argv[0] )); 
  }
  result = (uintptr_t)pn_void_hashcode(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_void_incref(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4556

SWIGINTERN VALUE
_wrap_pn_void_incref(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_incref", 1, argv[0] )); 
  }
  pn_void_incref(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pn_void_inspect(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4666

SWIGINTERN VALUE
_wrap_pn_void_inspect(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  pn_string_t *arg2 = (pn_string_t *) 0 ;
  int res1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_inspect", 1, argv[0] )); 
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_string_t *","pn_void_inspect", 2, argv[1] )); 
  }
  arg2 = (pn_string_t *)(argp2);
  result = (int)pn_void_inspect(arg1,arg2);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.pn_void_new(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4524

SWIGINTERN VALUE
_wrap_pn_void_new(int argc, VALUE *argv, VALUE self) {
  pn_class_t *arg1 = (pn_class_t *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_class_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_class_t const *","pn_void_new", 1, argv[0] )); 
  }
  arg1 = (pn_class_t *)(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","pn_void_new", 2, argv[1] ));
  } 
  arg2 = (size_t)(val2);
  result = (void *)pn_void_new((struct pn_class_t const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_void_refcount(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4594

SWIGINTERN VALUE
_wrap_pn_void_refcount(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pn_void_refcount", 1, argv[0] )); 
  }
  result = (int)pn_void_refcount(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

.PN_WEAKREF ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4148

SWIGINTERN VALUE
_wrap_PN_WEAKREF_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(PN_WEAKREF), SWIGTYPE_p_pn_class_t,  0 );
  return _val;
}

.pn_work_head(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 10982

SWIGINTERN VALUE
_wrap_pn_work_head(int argc, VALUE *argv, VALUE self) {
  pn_connection_t *arg1 = (pn_connection_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_t *","pn_work_head", 1, argv[0] )); 
  }
  arg1 = (pn_connection_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_delivery_t *)pn_work_head(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pn_work_next(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 11008

SWIGINTERN VALUE
_wrap_pn_work_next(int argc, VALUE *argv, VALUE self) {
  pn_delivery_t *arg1 = (pn_delivery_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_delivery_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_delivery_t *","pn_work_next", 1, argv[0] )); 
  }
  arg1 = (pn_delivery_t *)(argp1);
  SWIG_contract_assert((arg1!=NULL), "Contract violation: require: (arg1!=NULL)");
  
  result = (pn_delivery_t *)pn_work_next(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_delivery_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pni_address_of(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3576

SWIGINTERN VALUE
_wrap_pni_address_of(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pni_address_of", 1, argv[0] )); 
  }
  result = (VALUE)pni_address_of(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

.pni_connection_driver(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 4024

SWIGINTERN VALUE
_wrap_pni_connection_driver(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (pn_connection_driver_t *)pni_connection_driver();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pni_connection_driver_connection(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3938

SWIGINTERN VALUE
_wrap_pni_connection_driver_connection(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_connection_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pni_connection_driver_connection", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (pn_connection_t *)pni_connection_driver_connection(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_connection_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pni_connection_driver_read_copy(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3986

SWIGINTERN VALUE
_wrap_pni_connection_driver_read_copy(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pni_connection_driver_read_copy", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, &size2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","pni_connection_driver_read_copy", 2, argv[1] ));
  }  
  arg2 = (char *)(buf2);
  arg3 = (size_t)(size2 - 1);
  result = (size_t)pni_connection_driver_read_copy(arg1,arg2,arg3);
  vresult = SWIG_From_size_t((size_t)(result));
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

.pni_connection_driver_read_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3890

SWIGINTERN VALUE
_wrap_pni_connection_driver_read_size(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pni_connection_driver_read_size", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (size_t)pni_connection_driver_read_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pni_connection_driver_transport(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3962

SWIGINTERN VALUE
_wrap_pni_connection_driver_transport(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  pn_transport_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pni_connection_driver_transport", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (pn_transport_t *)pni_connection_driver_transport(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pn_transport_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pni_connection_driver_write_size(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3914

SWIGINTERN VALUE
_wrap_pni_connection_driver_write_size(int argc, VALUE *argv, VALUE self) {
  pn_connection_driver_t *arg1 = (pn_connection_driver_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_connection_driver_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_connection_driver_t *","pni_connection_driver_write_size", 1, argv[0] )); 
  }
  arg1 = (pn_connection_driver_t *)(argp1);
  result = (size_t)pni_connection_driver_write_size(arg1);
  vresult = SWIG_From_size_t((size_t)(result));
  return vresult;
fail:
  return Qnil;
}

.pni_rbdispatch(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3814

SWIGINTERN VALUE
_wrap_pni_rbdispatch(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 0 ;
  pn_event_t *arg2 = (pn_event_t *) 0 ;
  pn_event_type_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pni_rbdispatch", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_pn_event_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "pn_event_t *","pni_rbdispatch", 2, argv[1] )); 
  }
  arg2 = (pn_event_t *)(argp2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "pn_event_type_t","pni_rbdispatch", 3, argv[2] ));
  } 
  arg3 = (pn_event_type_t)(val3);
  pni_rbdispatch(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

.pni_rbhandler(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3790

SWIGINTERN VALUE
_wrap_pni_rbhandler(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Pni_rbhandler_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pni_rbhandler", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  result = (Pni_rbhandler_t *)pni_rbhandler(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pni_rbhandler_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

.pni_rbhandler_finalize(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3851

SWIGINTERN VALUE
_wrap_pni_rbhandler_finalize(int argc, VALUE *argv, VALUE self) {
  pn_handler_t *arg1 = (pn_handler_t *) 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(argv[0], &argp1,SWIGTYPE_p_pn_handler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "pn_handler_t *","pni_rbhandler_finalize", 1, argv[0] )); 
  }
  arg1 = (pn_handler_t *)(argp1);
  pni_rbhandler_finalize(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pni_ruby_add_to_registry(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3655

SWIGINTERN VALUE
_wrap_pni_ruby_add_to_registry(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  arg2 = argv[1];
  pni_ruby_add_to_registry(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

.pni_ruby_delete_from_registry(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3690

SWIGINTERN VALUE
_wrap_pni_ruby_delete_from_registry(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  pni_ruby_delete_from_registry(arg1);
  return Qnil;
fail:
  return Qnil;
}

.pni_ruby_get_from_registry(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3672

SWIGINTERN VALUE
_wrap_pni_ruby_get_from_registry(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (VALUE)pni_ruby_get_from_registry(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

.pni_ruby_get_proton_module(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3639

SWIGINTERN VALUE
_wrap_pni_ruby_get_proton_module(int argc, VALUE *argv, VALUE self) {
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (VALUE)pni_ruby_get_proton_module();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

.pni_void2rbkey(*args) ⇒ `Object`

# File 'ext/cproton/cproton.c', line 3514

SWIGINTERN VALUE
_wrap_pni_void2rbkey(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  Pn_rbkey_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","pni_void2rbkey", 1, argv[0] )); 
  }
  result = (Pn_rbkey_t *)pni_void2rbkey(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pn_rbkey_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

Module: Cproton

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Class Method Details

.pn_acceptor_close(*args) ⇒ Object

.pn_acceptor_set_ssl_domain(*args) ⇒ Object

.pn_bytes(*args) ⇒ Object

.pn_bytes_null ⇒ Object

.pn_cast_pn_connection(*args) ⇒ Object

.pn_cast_pn_delivery(*args) ⇒ Object

.pn_cast_pn_link(*args) ⇒ Object

.pn_cast_pn_reactor(*args) ⇒ Object

.pn_cast_pn_selectable(*args) ⇒ Object

.pn_cast_pn_session(*args) ⇒ Object

.pn_cast_pn_task(*args) ⇒ Object

.pn_cast_pn_transport(*args) ⇒ Object

.pn_class(*args) ⇒ Object

.pn_class_compare(*args) ⇒ Object

.pn_class_decref(*args) ⇒ Object

.pn_class_equals(*args) ⇒ Object

.pn_class_free(*args) ⇒ Object

.pn_class_hashcode(*args) ⇒ Object

.pn_class_id(*args) ⇒ Object

.pn_class_incref(*args) ⇒ Object

.pn_class_inspect(*args) ⇒ Object

.pn_class_name(*args) ⇒ Object

.pn_class_new(*args) ⇒ Object

.pn_class_reactor(*args) ⇒ Object

.pn_class_refcount(*args) ⇒ Object

.pn_class_reify(*args) ⇒ Object

.pn_code(*args) ⇒ Object

.pn_collector(*args) ⇒ Object

.pn_collector_drain(*args) ⇒ Object

.pn_collector_free(*args) ⇒ Object

.pn_collector_more(*args) ⇒ Object

.pn_collector_next(*args) ⇒ Object

.pn_collector_peek(*args) ⇒ Object

.pn_collector_pop(*args) ⇒ Object

.pn_collector_prev(*args) ⇒ Object

.pn_collector_put(*args) ⇒ Object

.pn_collector_release(*args) ⇒ Object

.pn_compare(*args) ⇒ Object

.pn_condition(*args) ⇒ Object

.pn_condition_clear(*args) ⇒ Object

.pn_condition_copy(*args) ⇒ Object

.pn_condition_free(*args) ⇒ Object

.pn_condition_get_description(*args) ⇒ Object

.pn_condition_get_name(*args) ⇒ Object

.pn_condition_info(*args) ⇒ Object

.pn_condition_is_redirect(*args) ⇒ Object

.pn_condition_is_set(*args) ⇒ Object

.pn_condition_redirect_host(*args) ⇒ Object

.pn_condition_redirect_port(*args) ⇒ Object

.pn_condition_set_description(*args) ⇒ Object

.pn_condition_set_name(*args) ⇒ Object

.pn_connection(*args) ⇒ Object

.pn_connection_acceptor(*args) ⇒ Object

.pn_connection_attachments(*args) ⇒ Object

.pn_connection_close(*args) ⇒ Object

.pn_connection_collect(*args) ⇒ Object

.pn_connection_collector(*args) ⇒ Object

.pn_connection_condition(*args) ⇒ Object

.pn_connection_desired_capabilities(*args) ⇒ Object

.pn_connection_driver_bind(*args) ⇒ Object

.pn_connection_driver_close(*args) ⇒ Object

.pn_connection_driver_destroy(*args) ⇒ Object

.pn_connection_driver_errorf(*args) ⇒ Object

.pn_connection_driver_finished(*args) ⇒ Object

.pn_connection_driver_has_event(*args) ⇒ Object

.pn_connection_driver_init(*args) ⇒ Object

.pn_connection_driver_log(*args) ⇒ Object

.pn_connection_driver_next_event(*args) ⇒ Object

.pn_connection_driver_ptr(*args) ⇒ Object

.pn_connection_driver_read_buffer(*args) ⇒ Object

.pn_connection_driver_read_close(*args) ⇒ Object

.pn_connection_driver_read_closed(*args) ⇒ Object

.pn_connection_driver_read_done(*args) ⇒ Object

.pn_connection_driver_release_connection(*args) ⇒ Object

.pn_connection_driver_write_buffer(*args) ⇒ Object