qpid_messaging 0.26.1 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66a95ea1f1b0a4de8f56ca71ee5c9128054e22d1
-  data.tar.gz: 5295d2b8e6aa4bb771f8740998313231b5b0623d
+  metadata.gz: 14a54951e817102eeb8c5fb8315071a7754506eb
+  data.tar.gz: 91b49da2eb9eec0574c6a85a1a549e4055797d80
 SHA512:
-  metadata.gz: 04a517ad6b5d872bd542b9467c155b7e85350ddb2b1d3b5cbc6b050d3125a43fe0903b26de86173cf68a716287e1f96b5e61c5347553cff214f2269ec95e69e1
-  data.tar.gz: 3ba31ebf0bf615c34d88f36a3a48dd36ef6a52617ffd2ed677d91fc0ad072c3e0731d5527b48187f88c2983d96ebb1256273aeb17520c35c1d67de4a5ee7c8a5
+  metadata.gz: b439f5054d7fa6096e39c4ad9df66af89598c879487dbf1224a0524f09525d9322e8ac41c71bc5fde3c232e7f65f32efa3713d6ef5785c72dac9ccbebb3c6798
+  data.tar.gz: 97115daa78898c87627122ce05730de7f1ee4efa52a37f10c6441b7b5dab4193fb990340f171ef0f84e89a3ee11869f19a8ebfa6562a366ae4cd42d7a40ce56d

data/examples/client.rb

@@ -40,7 +40,7 @@ if __FILE__ == $0
     request.reply_to = response_queue
     sender.send request
     response = receiver.fetch
-    puts "#{request.content} -> #{response.content}"
+    puts "#{request.content_object} -> #{response.content_object}"
   end
 
   connection.close

data/examples/drain.rb

@@ -93,11 +93,11 @@ begin
     message = receiver.fetch(options[:timeout])
     print "Message(properties="
     render_map message.properties
-    print ", content="
-    if message.content_type == "amqp/map"
-      print "'#{render_map message.content}')"
+    print ", content_object="
+    if message.content_object == "amqp/map"
+      print "'#{render_map message.content_object}')"
     else
-      print "'#{message.content}'"
+      print "'#{message.content_object}'"
     end
     print ")\n"
     session.acknowledge message

data/examples/hello_world.rb

@@ -41,7 +41,7 @@ if __FILE__ == $0
 
   # Now receive the message
   message = receiver.fetch Qpid::Messaging::Duration::SECOND
-  puts "#{message.content}"
+  puts "#{message.content_object}"
   session.acknowledge
 
   connection.close

data/examples/map_receiver.rb

@@ -44,7 +44,7 @@ begin
   receiver = session.create_receiver address
 
   message = receiver.fetch
-  content = message.content
+  content = message.content_object
 
   print "content-type:#{message.content_type}"
   print "{"

data/examples/map_sender.rb

@@ -23,7 +23,7 @@ require 'qpid_messaging'
 
 broker  = ARGV[0] || "amqp:tcp:127.0.0.1:5672"
 address = ARGV[1] || "message_queue; {create: always}"
-options = ARGV[2] || []
+options = ARGV[2] || {}
 
 connection = Qpid::Messaging::Connection.new :url => broker, :options => options
 connection.open
@@ -34,18 +34,19 @@ begin
   message = Qpid::Messaging::Message.new
 
   content = {
-    :id      => 987654321,
+    "id"     => 987654321,
     :name    => "Widget",
     :percent => 0.99,
     :colors  => ["red", "green", "blue"]
   }
 
-  message.content = content
+  message.content_object = content
 
   sender.send message
 
 rescue Exception => error
   puts "Exception: #{error.message}"
+  puts error.backtrace
 end
 
 connection.close

data/examples/server.rb

@@ -36,12 +36,12 @@ if __FILE__ == $0
 
     if !address.nil?
       sender = session.create_sender address
-      response = Qpid::Messaging::Message.new :content => request.content.upcase
+      response = Qpid::Messaging::Message.new :content => request.content_object.upcase
       sender.send response
-      puts "Processed request: #{request.content} -> #{response.content}"
+      puts "Processed request: #{request.content_object} -> #{response.content_object}"
       session.acknowledge
     else
-      puts "Error: no reply address specified for request: #{request.content}"
+      puts "Error: no reply address specified for request: #{request.content_object}"
       session.reject request
     end
   end

data/examples/spout.rb

@@ -109,9 +109,9 @@ options[:address] = ARGV[0] unless ARGV[0].nil?
 
 # process the connection options
 unless options[:connection_options].nil?
-  fields = options[:connection_options].gsub(/^{(.*)}$/, '\1')
+  fields = options[:connection_options].gsub(/^\{(.*)\}$/, '\1')
   # remove any surrounding braces
-  if /{.*}/ =~ fields
+  if /\{.*\}/ =~ fields
     fields = fields[1..-2]
   end
   # break up the options separated by commas
@@ -137,12 +137,12 @@ options[:properties].each_key {|key| message[key] = options[:properties][key]}
 
 (1..options[:count]).each do |count|
   if !options[:mapped].keys.empty?
-    message.content = options[:mapped]
+    message.content_object = options[:mapped]
   elsif options[:content]
-    message.content = options[:content]
+    message.content_object = options[:content]
   end
   message.durable = options[:durable]
-  message.content = options[:content] unless options[:content].nil?
+  message.content_object = options[:content] unless options[:content].nil?
   message.properties["spout-id"] = "#{count}"
   message.reply_to = options[:replyto] unless options[:replyto].nil? || options[:replyto].empty?
   sender.send message

data/ext/cqpid/cqpid.cpp

@@ -1803,22 +1803,25 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 /* -------- TYPES TABLE (BEGIN) -------- */
 
 #define SWIGTYPE_p_char swig_types[0]
-#define SWIGTYPE_p_qpid__messaging__Address swig_types[1]
-#define SWIGTYPE_p_qpid__messaging__Connection swig_types[2]
-#define SWIGTYPE_p_qpid__messaging__ConnectionImpl swig_types[3]
-#define SWIGTYPE_p_qpid__messaging__Duration swig_types[4]
-#define SWIGTYPE_p_qpid__messaging__EncodingException swig_types[5]
-#define SWIGTYPE_p_qpid__messaging__FailoverUpdates swig_types[6]
-#define SWIGTYPE_p_qpid__messaging__Message swig_types[7]
-#define SWIGTYPE_p_qpid__messaging__Receiver swig_types[8]
-#define SWIGTYPE_p_qpid__messaging__ReceiverImpl swig_types[9]
-#define SWIGTYPE_p_qpid__messaging__Sender swig_types[10]
-#define SWIGTYPE_p_qpid__messaging__SenderImpl swig_types[11]
-#define SWIGTYPE_p_qpid__messaging__Session swig_types[12]
-#define SWIGTYPE_p_qpid__messaging__SessionImpl swig_types[13]
-#define SWIGTYPE_p_uint8_t swig_types[14]
-static swig_type_info *swig_types[16];
-static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
+#define SWIGTYPE_p_p_char swig_types[1]
+#define SWIGTYPE_p_qpid__messaging__Address swig_types[2]
+#define SWIGTYPE_p_qpid__messaging__Connection swig_types[3]
+#define SWIGTYPE_p_qpid__messaging__ConnectionImpl swig_types[4]
+#define SWIGTYPE_p_qpid__messaging__Duration swig_types[5]
+#define SWIGTYPE_p_qpid__messaging__EncodingException swig_types[6]
+#define SWIGTYPE_p_qpid__messaging__FailoverUpdates swig_types[7]
+#define SWIGTYPE_p_qpid__messaging__Logger swig_types[8]
+#define SWIGTYPE_p_qpid__messaging__LoggerOutput swig_types[9]
+#define SWIGTYPE_p_qpid__messaging__Message swig_types[10]
+#define SWIGTYPE_p_qpid__messaging__Receiver swig_types[11]
+#define SWIGTYPE_p_qpid__messaging__ReceiverImpl swig_types[12]
+#define SWIGTYPE_p_qpid__messaging__Sender swig_types[13]
+#define SWIGTYPE_p_qpid__messaging__SenderImpl swig_types[14]
+#define SWIGTYPE_p_qpid__messaging__Session swig_types[15]
+#define SWIGTYPE_p_qpid__messaging__SessionImpl swig_types[16]
+#define SWIGTYPE_p_uint8_t swig_types[17]
+static swig_type_info *swig_types[19];
+static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1863,6 +1866,7 @@ struct mystr
 #include <qpid/messaging/Message.h>
 #include <qpid/messaging/Duration.h>
 #include <qpid/messaging/FailoverUpdates.h>
+#include <qpid/messaging/Logger.h>
 
 //
 // Wrapper functions for map-decode and list-decode.  This allows us to avoid
@@ -2143,6 +2147,13 @@ SWIGINTERN mystr qpid_messaging_Message_getContentPtr(qpid::messaging::Message *
     return s;
   }
 
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
 
 
 
@@ -22518,6 +22529,870 @@ free_qpid_messaging_FailoverUpdates(qpid::messaging::FailoverUpdates *arg1) {
     delete arg1;
 }
 
+static swig_class SwigClassLoggerOutput;
+
+SWIGINTERN void
+free_qpid_messaging_LoggerOutput(qpid::messaging::LoggerOutput *arg1) {
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_LoggerOutput_log(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::LoggerOutput *arg1 = (qpid::messaging::LoggerOutput *) 0 ;
+  qpid::messaging::Level arg2 ;
+  bool arg3 ;
+  char *arg4 = (char *) 0 ;
+  int arg5 ;
+  char *arg6 = (char *) 0 ;
+  std::string *arg7 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  int res4 ;
+  char *buf4 = 0 ;
+  int alloc4 = 0 ;
+  int val5 ;
+  int ecode5 = 0 ;
+  int res6 ;
+  char *buf6 = 0 ;
+  int alloc6 = 0 ;
+  int res7 = SWIG_OLDOBJ ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_qpid__messaging__LoggerOutput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::LoggerOutput *","log", 1, self )); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::LoggerOutput * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "qpid::messaging::Level","log", 2, argv[0] ));
+  } 
+  arg2 = static_cast< qpid::messaging::Level >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","log", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","log", 4, argv[2] ));
+  }
+  arg4 = reinterpret_cast< char * >(buf4);
+  ecode5 = SWIG_AsVal_int(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","log", 5, argv[3] ));
+  } 
+  arg5 = static_cast< int >(val5);
+  res6 = SWIG_AsCharPtrAndSize(argv[4], &buf6, NULL, &alloc6);
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "char const *","log", 6, argv[4] ));
+  }
+  arg6 = reinterpret_cast< char * >(buf6);
+  {
+    std::string *ptr = (std::string *)0;
+    res7 = SWIG_AsPtr_std_string(argv[5], &ptr);
+    if (!SWIG_IsOK(res7)) {
+      SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "std::string const &","log", 7, argv[5] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","log", 7, argv[5])); 
+    }
+    arg7 = ptr;
+  }
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      (arg1)->log(arg2,arg3,(char const *)arg4,arg5,(char const *)arg6,(std::string const &)*arg7);
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
+  if (SWIG_IsNewObj(res7)) delete arg7;
+  return Qnil;
+fail:
+  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
+  if (SWIG_IsNewObj(res7)) delete arg7;
+  return Qnil;
+}
+
+
+static swig_class SwigClassLogger;
+
+SWIGINTERN VALUE
+_wrap_Logger_configure__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  char **arg2 ;
+  std::string *arg3 = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res3 = SWIG_OLDOBJ ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","qpid::messaging::Logger::configure", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *[]","qpid::messaging::Logger::configure", 2, argv[1] )); 
+  } 
+  arg2 = reinterpret_cast< char ** >(argp2);
+  {
+    std::string *ptr = (std::string *)0;
+    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","qpid::messaging::Logger::configure", 3, argv[2] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","qpid::messaging::Logger::configure", 3, argv[2])); 
+    }
+    arg3 = ptr;
+  }
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      qpid::messaging::Logger::configure(arg1,(char const *(*))arg2,(std::string const &)*arg3);
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Logger_configure__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  char **arg2 ;
+  int val1 ;
+  int ecode1 = 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;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","qpid::messaging::Logger::configure", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *[]","qpid::messaging::Logger::configure", 2, argv[1] )); 
+  } 
+  arg2 = reinterpret_cast< char ** >(argp2);
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      qpid::messaging::Logger::configure(arg1,(char const *(*))arg2);
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Logger_configure(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_Logger_configure__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Logger_configure__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "Logger.configure", 
+    "    void Logger.configure(int argc, char const *argv[], std::string const &prefix)\n"
+    "    void Logger.configure(int argc, char const *argv[])\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Logger_usage(int argc, VALUE *argv, VALUE self) {
+  std::string result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      result = qpid::messaging::Logger::usage();
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Logger_setOutput(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::LoggerOutput *arg1 = 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_qpid__messaging__LoggerOutput,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "qpid::messaging::LoggerOutput &","qpid::messaging::Logger::setOutput", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "qpid::messaging::LoggerOutput &","qpid::messaging::Logger::setOutput", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< qpid::messaging::LoggerOutput * >(argp1);
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      qpid::messaging::Logger::setOutput(*arg1);
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Logger_log(int argc, VALUE *argv, VALUE self) {
+  qpid::messaging::Level arg1 ;
+  char *arg2 = (char *) 0 ;
+  int arg3 ;
+  char *arg4 = (char *) 0 ;
+  std::string *arg5 = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int res4 ;
+  char *buf4 = 0 ;
+  int alloc4 = 0 ;
+  int res5 = SWIG_OLDOBJ ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "qpid::messaging::Level","qpid::messaging::Logger::log", 1, argv[0] ));
+  } 
+  arg1 = static_cast< qpid::messaging::Level >(val1);
+  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","qpid::messaging::Logger::log", 2, argv[1] ));
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","qpid::messaging::Logger::log", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","qpid::messaging::Logger::log", 4, argv[3] ));
+  }
+  arg4 = reinterpret_cast< char * >(buf4);
+  {
+    std::string *ptr = (std::string *)0;
+    res5 = SWIG_AsPtr_std_string(argv[4], &ptr);
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "std::string const &","qpid::messaging::Logger::log", 5, argv[4] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","qpid::messaging::Logger::log", 5, argv[4])); 
+    }
+    arg5 = ptr;
+  }
+  {
+    static VALUE eMessagingError = rb_define_class("MessagingError",
+      rb_eStandardError);
+    
+    try {
+      qpid::messaging::Logger::log(arg1,(char const *)arg2,arg3,(char const *)arg4,(std::string const &)*arg5);
+    }
+    catch(qpid::messaging::ConnectionError& error) {
+      static VALUE merror = rb_define_class("ConnectionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransportFailure& error) {
+      static VALUE merror = rb_define_class("TransportFailure", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionAborted& error) {
+      static VALUE merror = rb_define_class("TransactionAborted", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TransactionError& error) {
+      static VALUE merror = rb_define_class("TransactionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::UnauthorizedAccess& error) {
+      static VALUE merror = rb_define_class("UnauthorizedAccess", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SessionError& error) {
+      static VALUE merror = rb_define_class("SessionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::TargetCapacityExceeded& error) {
+      static VALUE merror = rb_define_class("TargetCapacityExceeded", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SendError& error) {
+      static VALUE merror = rb_define_class("SendError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::SenderError& error) {
+      static VALUE merror = rb_define_class("SenderError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NoMessageAvailable& error) {
+      static VALUE merror = rb_define_class("NoMessageAvailable", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::FetchError& error) {
+      static VALUE merror = rb_define_class("FetchError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ReceiverError& error) {
+      static VALUE merror = rb_define_class("ReceiverError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::InvalidOptionString& error) {
+      static VALUE merror = rb_define_class("InvalidOptionString", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::KeyError& error) {
+      static VALUE merror = rb_define_class("KeyError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AssertionFailed& error) {
+      static VALUE merror = rb_define_class("AssertionFailed", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::NotFound& error) {
+      static VALUE merror = rb_define_class("NotFound", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::ResolutionError& error) {
+      static VALUE merror = rb_define_class("ResolutionError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MalformedAddress& error) {
+      static VALUE merror = rb_define_class("MalformedAddress", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::AddressError& error) {
+      static VALUE merror = rb_define_class("AddressError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::LinkError& error) {
+      static VALUE merror = rb_define_class("LinkError", eMessagingError);
+      rb_raise(merror, "%s", error.what());
+    }
+    catch(qpid::messaging::MessagingException& error) {
+      rb_raise(eMessagingError, "%s", error.what());
+    }
+  }
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (SWIG_IsNewObj(res5)) delete arg5;
+  return Qnil;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
+  if (SWIG_IsNewObj(res5)) delete arg5;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_decodeMap(int argc, VALUE *argv, VALUE self) {
   qpid::messaging::Message *arg1 = 0 ;
@@ -22760,12 +23635,15 @@ fail:
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__Address = {"_p_qpid__messaging__Address", "qpid::messaging::Address *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__Connection = {"_p_qpid__messaging__Connection", "qpid::messaging::Connection *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__ConnectionImpl = {"_p_qpid__messaging__ConnectionImpl", "qpid::messaging::ConnectionImpl *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__Duration = {"_p_qpid__messaging__Duration", "qpid::messaging::Duration *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__EncodingException = {"_p_qpid__messaging__EncodingException", "qpid::messaging::EncodingException *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__FailoverUpdates = {"_p_qpid__messaging__FailoverUpdates", "qpid::messaging::FailoverUpdates *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_qpid__messaging__Logger = {"_p_qpid__messaging__Logger", "qpid::messaging::Logger *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_qpid__messaging__LoggerOutput = {"_p_qpid__messaging__LoggerOutput", "qpid::messaging::LoggerOutput *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__Message = {"_p_qpid__messaging__Message", "qpid::messaging::Message *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__Receiver = {"_p_qpid__messaging__Receiver", "qpid::messaging::Receiver *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_qpid__messaging__ReceiverImpl = {"_p_qpid__messaging__ReceiverImpl", "qpid::messaging::ReceiverImpl *", 0, 0, (void*)0, 0};
@@ -22777,12 +23655,15 @@ static swig_type_info _swigt__p_uint8_t = {"_p_uint8_t", "uint8_t *", 0, 0, (voi
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_char,
+  &_swigt__p_p_char,
   &_swigt__p_qpid__messaging__Address,
   &_swigt__p_qpid__messaging__Connection,
   &_swigt__p_qpid__messaging__ConnectionImpl,
   &_swigt__p_qpid__messaging__Duration,
   &_swigt__p_qpid__messaging__EncodingException,
   &_swigt__p_qpid__messaging__FailoverUpdates,
+  &_swigt__p_qpid__messaging__Logger,
+  &_swigt__p_qpid__messaging__LoggerOutput,
   &_swigt__p_qpid__messaging__Message,
   &_swigt__p_qpid__messaging__Receiver,
   &_swigt__p_qpid__messaging__ReceiverImpl,
@@ -22794,12 +23675,15 @@ static swig_type_info *swig_type_initial[] = {
 };
 
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__Address[] = {  {&_swigt__p_qpid__messaging__Address, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__Connection[] = {  {&_swigt__p_qpid__messaging__Connection, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__ConnectionImpl[] = {  {&_swigt__p_qpid__messaging__ConnectionImpl, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__Duration[] = {  {&_swigt__p_qpid__messaging__Duration, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__EncodingException[] = {  {&_swigt__p_qpid__messaging__EncodingException, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__FailoverUpdates[] = {  {&_swigt__p_qpid__messaging__FailoverUpdates, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_qpid__messaging__Logger[] = {  {&_swigt__p_qpid__messaging__Logger, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_qpid__messaging__LoggerOutput[] = {  {&_swigt__p_qpid__messaging__LoggerOutput, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__Message[] = {  {&_swigt__p_qpid__messaging__Message, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__Receiver[] = {  {&_swigt__p_qpid__messaging__Receiver, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_qpid__messaging__ReceiverImpl[] = {  {&_swigt__p_qpid__messaging__ReceiverImpl, 0, 0, 0},{0, 0, 0, 0}};
@@ -22811,12 +23695,15 @@ static swig_cast_info _swigc__p_uint8_t[] = {  {&_swigt__p_uint8_t, 0, 0, 0},{0,
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_char,
+  _swigc__p_p_char,
   _swigc__p_qpid__messaging__Address,
   _swigc__p_qpid__messaging__Connection,
   _swigc__p_qpid__messaging__ConnectionImpl,
   _swigc__p_qpid__messaging__Duration,
   _swigc__p_qpid__messaging__EncodingException,
   _swigc__p_qpid__messaging__FailoverUpdates,
+  _swigc__p_qpid__messaging__Logger,
+  _swigc__p_qpid__messaging__LoggerOutput,
   _swigc__p_qpid__messaging__Message,
   _swigc__p_qpid__messaging__Receiver,
   _swigc__p_qpid__messaging__ReceiverImpl,
@@ -23253,6 +24140,31 @@ SWIGEXPORT void Init_cqpid(void) {
   SwigClassFailoverUpdates.mark = 0;
   SwigClassFailoverUpdates.destroy = (void (*)(void *)) free_qpid_messaging_FailoverUpdates;
   SwigClassFailoverUpdates.trackObjects = 0;
+  rb_define_const(mCqpid, "Trace", SWIG_From_int(static_cast< int >(qpid::messaging::trace)));
+  rb_define_const(mCqpid, "Debug", SWIG_From_int(static_cast< int >(qpid::messaging::debug)));
+  rb_define_const(mCqpid, "Info", SWIG_From_int(static_cast< int >(qpid::messaging::info)));
+  rb_define_const(mCqpid, "Notice", SWIG_From_int(static_cast< int >(qpid::messaging::notice)));
+  rb_define_const(mCqpid, "Warning", SWIG_From_int(static_cast< int >(qpid::messaging::warning)));
+  rb_define_const(mCqpid, "Error", SWIG_From_int(static_cast< int >(qpid::messaging::error)));
+  rb_define_const(mCqpid, "Critical", SWIG_From_int(static_cast< int >(qpid::messaging::critical)));
+  
+  SwigClassLoggerOutput.klass = rb_define_class_under(mCqpid, "LoggerOutput", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_qpid__messaging__LoggerOutput, (void *) &SwigClassLoggerOutput);
+  rb_undef_alloc_func(SwigClassLoggerOutput.klass);
+  rb_define_method(SwigClassLoggerOutput.klass, "log", VALUEFUNC(_wrap_LoggerOutput_log), -1);
+  SwigClassLoggerOutput.mark = 0;
+  SwigClassLoggerOutput.destroy = (void (*)(void *)) free_qpid_messaging_LoggerOutput;
+  SwigClassLoggerOutput.trackObjects = 0;
+  
+  SwigClassLogger.klass = rb_define_class_under(mCqpid, "Logger", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_qpid__messaging__Logger, (void *) &SwigClassLogger);
+  rb_undef_alloc_func(SwigClassLogger.klass);
+  rb_define_singleton_method(SwigClassLogger.klass, "configure", VALUEFUNC(_wrap_Logger_configure), -1);
+  rb_define_singleton_method(SwigClassLogger.klass, "usage", VALUEFUNC(_wrap_Logger_usage), -1);
+  rb_define_singleton_method(SwigClassLogger.klass, "setOutput", VALUEFUNC(_wrap_Logger_setOutput), -1);
+  rb_define_singleton_method(SwigClassLogger.klass, "log", VALUEFUNC(_wrap_Logger_log), -1);
+  SwigClassLogger.mark = 0;
+  SwigClassLogger.trackObjects = 0;
   rb_define_module_function(mCqpid, "decodeMap", VALUEFUNC(_wrap_decodeMap), -1);
   rb_define_module_function(mCqpid, "decodeList", VALUEFUNC(_wrap_decodeList), -1);
 }

data/lib/qpid_messaging/message.rb

@@ -39,9 +39,8 @@ module Qpid
       def initialize(args = {})
         @message_impl = (args[:impl] if args[:impl]) || nil
         @message_impl = Cqpid::Message.new if @message_impl.nil?
-        @content = nil
         args = {} if args.nil?
-        self.content = args[:content] if args[:content]
+        self.content_object = args[:content] if args[:content]
       end
 
       def message_impl # :nodoc:
@@ -345,6 +344,29 @@ module Qpid
       # Returns the content's size in bytes.
       def content_size; @message_impl.getContentSize; end
 
+      # Sets the message content.
+      #
+      # ==== Options
+      #
+      # * +content+ - the content
+      #
+      # ==== Examples
+      #
+      #   # set a simple content for a message
+      #   msg.content_object = "This is a simple message."
+      #   # sets content that is automatically encoded
+      #   msg.content_object = {:foo => :bar}
+      #
+      def content_object=(content)
+        @message_impl.setContentObject(Qpid::Messaging.stringify(content))
+      end
+
+      # Returns the content of the +Message+.
+      #
+      def content_object
+        @message_impl.getContentObject()
+      end
+
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qpid_messaging
 version: !ruby/object:Gem::Version
-  version: 0.26.1
+  version: 0.30.0
 platform: ruby
 authors:
 - Apache Qpid Project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-21 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies: []
 description: Qpid is an enterprise messaging framework.
 email: dev@qpid.apache.org