activemq 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+*.gem
+.bundle
+.project
+*.o
+*.so
+tmp/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.8.7-p302@rbactivemq --create

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in RBActivemq.gemspec
+gemspec
+
+group :test, :development do
+  platforms :mri_18 do
+    gem "ruby-debug"
+  end
+
+  platforms :mri_19 do
+    gem "ruby-debug19", :require => 'ruby-debug' if RUBY_VERSION < "1.9.3"
+  end
+end

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    activemq (0.0.1)
+      rice (>= 1.4.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.2)
+    diff-lcs (1.1.2)
+    linecache (0.43)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    rake (0.8.7)
+    rake-compiler (0.7.7)
+      rake
+    rice (1.4.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemq!
+  rake-compiler (>= 0.7.7)
+  rspec (>= 2.3.0)
+  ruby-debug
+  ruby-debug19

data/README.textile

@@ -0,0 +1,52 @@
+h1. Ruby ActiveMQ
+
+ActiveMQ client for Ruby using openwire protocol through activemq-cpp client.
+
+h2(#changelog). Changelog
+
+*0.0.1* - Initial version with support to publish text messages
+
+h2(#installing). Installing
+
+*You must install the "ActiveMQ-cpp":http://activemq.apache.org/cms/activemq-cpp-325-release.html 3.2.5 version previously*
+
+<pre>
+<code>
+  gem install activemq
+</code>
+</pre>
+
+If needed you can pass where is the activemq-cpp, library and includes, example:
+
+<pre>
+<code>
+  gem install activemq -- --with-activemq-cpp-lib=/opt/activemq-cpp-3.2.5/lib --with-activemq-cpp-include=/opt/activemq-cpp-3.2.5/include/activemq-cpp-3.2.5
+</code>
+</pre>
+
+h2(#basic-usage). Basic Usage
+
+_Considering default configuration of ActiveMQ server_
+
+h3. Publish Message
+<pre>
+<code>
+  require 'activemq'
+  amqcf = ActiveMQ::ConnectionFactory.new
+  connection = amqcf.create_connection
+  session = connection.create_session
+  topic = session.create_topic("topic_name")
+  producer = session.create_producer(topic)
+  message = session.create_text_message("Text to send")
+  producer.send_message(message)
+  connection.close
+</code>
+</pre>
+
+h2(#todo). TODO
+
+* Add Properties to messages
+* Exception listener
+* Consumer by pooling
+* Consumer by stream
+* Work with Bytes and Map messages

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# use rake-compiler for building the extension
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('ActiveMQ') do |ext|
+  ext.source_pattern = "*.{c,cpp}"
+end
+
+require "rspec/core/rake_task"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec => "compile:ActiveMQ")

data/activemq.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "activemq/version"
+
+Gem::Specification.new do |s|
+  s.name        = "activemq"
+  s.version     = ActiveMQ::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Wandenberg Peixoto"]
+  s.email       = ["wandenberg@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{ActiveMQ client for Ruby}
+  s.description = %q{ActiveMQ client for Ruby using openwire protocol through activemq-cpp client}
+
+  s.rubyforge_project = "activemq"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extensions = "ext/ActiveMQ/extconf.rb"
+
+  s.add_dependency "rice", ">= 1.4.2"
+
+  s.add_development_dependency "rake-compiler", ">= 0.7.7"
+  s.add_development_dependency "rspec", ">= 2.3.0"
+
+end

data/ext/ActiveMQ/Connection.cpp

@@ -0,0 +1,16 @@
+#include "activemq.hpp"
+
+void register_Connection(Module rb_module) {
+
+	cms::Session* (cms::Connection::*Connection_createSession1)(cms::Session::AcknowledgeMode) = &cms::Connection::createSession;
+
+	Data_Type< cms::Connection > rb_cConnection =  define_class_under< cms::Connection >(rb_module, "Connection");
+	rb_cConnection.define_method("instance?", &instance, (Arg("class")));
+
+	rb_cConnection.define_method("create_session", Connection_createSession1, (Arg("acknowledge_mode") = cms::Session::AUTO_ACKNOWLEDGE));
+
+	rb_cConnection.define_method("client_id", &cms::Connection::getClientID);
+	rb_cConnection.define_method("client_id=", &cms::Connection::setClientID, (Arg("client_id")));
+
+	rb_cConnection.define_method("close", &cms::Connection::close);
+}

data/ext/ActiveMQ/ConnectionFactory.cpp

@@ -0,0 +1,30 @@
+#include "activemq.hpp"
+
+void register_ConnectionFactory(Module rb_module)
+{
+	Data_Type< activemq::core::ActiveMQConnectionFactory > rb_cConnectionFactory =  define_class_under< activemq::core::ActiveMQConnectionFactory >(rb_module, "ConnectionFactory");
+	rb_cConnectionFactory.define_method("instance?", &instance, (Arg("class")));
+
+	rb_cConnectionFactory.define_constructor(Constructor< activemq::core::ActiveMQConnectionFactory,const std::string&,const std::string&,const std::string& >(), (Arg("broker_url") = new std::string(activemq::core::ActiveMQConnectionFactory::DEFAULT_URI), Arg("username") = new std::string(""), Arg("password") = new std::string("")));
+	rb_cConnectionFactory.const_set("DEFAULT_URI", to_ruby(activemq::core::ActiveMQConnectionFactory::DEFAULT_URI));
+
+	rb_cConnectionFactory.define_method("username", &activemq::core::ActiveMQConnectionFactory::getUsername);
+	rb_cConnectionFactory.define_method("username=", &activemq::core::ActiveMQConnectionFactory::setUsername, (Arg("username")));
+
+	rb_cConnectionFactory.define_method("password", &activemq::core::ActiveMQConnectionFactory::getPassword);
+	rb_cConnectionFactory.define_method("password=", &activemq::core::ActiveMQConnectionFactory::setPassword, (Arg("password")));
+
+	rb_cConnectionFactory.define_method("broker_url", &activemq::core::ActiveMQConnectionFactory::getBrokerURL);
+	rb_cConnectionFactory.define_method("broker_url=", &activemq::core::ActiveMQConnectionFactory::setBrokerURL, (Arg("broker_url")));
+
+	rb_cConnectionFactory.define_method("client_id", &activemq::core::ActiveMQConnectionFactory::getClientId);
+	rb_cConnectionFactory.define_method("client_id=", &activemq::core::ActiveMQConnectionFactory::setClientId, (Arg("client_id")));
+
+	cms::Connection* (activemq::core::ActiveMQConnectionFactory::*ConnectionFactory_createConnection0)() = &activemq::core::ActiveMQConnectionFactory::createConnection;
+	cms::Connection* (activemq::core::ActiveMQConnectionFactory::*ConnectionFactory_createConnection2)(const std::string&, const std::string&) = &activemq::core::ActiveMQConnectionFactory::createConnection;
+	cms::Connection* (activemq::core::ActiveMQConnectionFactory::*ConnectionFactory_createConnection3)(const std::string&, const std::string&, const std::string&) = &activemq::core::ActiveMQConnectionFactory::createConnection;
+
+	rb_cConnectionFactory.define_method("create_connection", ConnectionFactory_createConnection0);
+	rb_cConnectionFactory.define_method("create_connection_for", ConnectionFactory_createConnection2, (Arg("username"), Arg("password")));
+	rb_cConnectionFactory.define_method("create_connection_for_client", ConnectionFactory_createConnection3, (Arg("username"), Arg("password"), Arg("clientId")));
+}

data/ext/ActiveMQ/DeliveryMode.cpp

@@ -0,0 +1,10 @@
+#include "activemq.hpp"
+
+void register_DeliveryMode(Module rb_module) {
+	Data_Type< cms::DeliveryMode > rb_cDeliveryMode =  define_class_under< cms::DeliveryMode >(rb_module, "DeliveryMode");
+	rb_cDeliveryMode.define_constructor(Constructor< cms::DeliveryMode >());
+	rb_cDeliveryMode.define_method("instance?", &instance, (Arg("class")));
+
+	rb_cDeliveryMode.const_set("PERSISTENT", to_ruby((int)cms::DeliveryMode::PERSISTENT));
+	rb_cDeliveryMode.const_set("NON_PERSISTENT", to_ruby((int)cms::DeliveryMode::NON_PERSISTENT));
+}

data/ext/ActiveMQ/Destinations.cpp

@@ -0,0 +1,28 @@
+#include "activemq.hpp"
+
+void register_Destinations(Module rb_module) {
+	Data_Type< cms::Destination > rb_cDestination =  define_class_under< cms::Destination >(rb_module, "Destination");
+	rb_cDestination.define_method("instance?", &instance, (Arg("class")));
+
+	rb_cDestination.define_method("destination_type", &cms::Destination::getDestinationType);
+//	rb_cDestination.define_method("clone", &cms::Destination::clone);
+//	rb_cDestination.define_method("copy", &cms::Destination::copy, (Arg("source")));
+
+	Data_Type< cms::Topic > rb_cTopic = define_class_under< cms::Topic, cms::Destination >(rb_module, "Topic");
+	rb_cTopic.define_method("name", &cms::Topic::getTopicName);
+
+	Data_Type< cms::Queue > rb_cQueue =  define_class_under< cms::Queue,cms::Destination >(rb_module, "Queue");
+	rb_cQueue.define_method("name", &cms::Queue::getQueueName);
+
+	Data_Type< cms::TemporaryTopic > rb_cTemporaryTopic = define_class_under< cms::TemporaryTopic, cms::Destination >(rb_module, "TemporaryTopic");
+	rb_cTemporaryTopic.define_method("name", &cms::TemporaryTopic::getTopicName);
+
+	Data_Type< cms::TemporaryQueue > rb_cTemporaryQueue =  define_class_under< cms::TemporaryQueue,cms::Destination >(rb_module, "TemporaryQueue");
+	rb_cTemporaryQueue.define_method("name", &cms::TemporaryQueue::getQueueName);
+
+	Enum<cms::Destination::DestinationType> rb_eDestinationType = define_enum<cms::Destination::DestinationType>("DestinationType", rb_cDestination);
+	rb_eDestinationType.define_value("TOPIC", cms::Destination::TOPIC);
+	rb_eDestinationType.define_value("QUEUE", cms::Destination::QUEUE);
+	rb_eDestinationType.define_value("TEMPORARY_TOPIC", cms::Destination::TEMPORARY_TOPIC);
+	rb_eDestinationType.define_value("TEMPORARY_QUEUE", cms::Destination::TEMPORARY_QUEUE);
+}

data/ext/ActiveMQ/Message.cpp

@@ -0,0 +1,68 @@
+#include "activemq.hpp"
+
+void register_Message(Module rb_module) {
+	Data_Type< cms::Message > rb_cMessage = define_class_under< cms::Message >(rb_module, "Message");
+	rb_cMessage.define_method("instance?", &instance, (Arg("class")));
+
+//	rb_cMessage.define_method("getIntProperty", &cms::Message::getIntProperty, (Arg("name")));
+//	rb_cMessage.define_method("setIntProperty", &cms::Message::setIntProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getByteProperty", &cms::Message::getByteProperty, (Arg("name")));
+//	rb_cMessage.define_method("setByteProperty", &cms::Message::setByteProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getBooleanProperty", &cms::Message::getBooleanProperty, (Arg("name")));
+//	rb_cMessage.define_method("setBooleanProperty", &cms::Message::setBooleanProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getDoubleProperty", &cms::Message::getDoubleProperty, (Arg("name")));
+//	rb_cMessage.define_method("setDoubleProperty", &cms::Message::setDoubleProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getFloatProperty", &cms::Message::getFloatProperty, (Arg("name")));
+//	rb_cMessage.define_method("setFloatProperty", &cms::Message::setFloatProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getLongProperty", &cms::Message::getLongProperty, (Arg("name")));
+//	rb_cMessage.define_method("setLongProperty", &cms::Message::setLongProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getShortProperty", &cms::Message::getShortProperty, (Arg("name")));
+//	rb_cMessage.define_method("setShortProperty", &cms::Message::setShortProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("getStringProperty", &cms::Message::getStringProperty, (Arg("name")));
+//	rb_cMessage.define_method("setStringProperty", &cms::Message::setStringProperty, (Arg("name"), Arg("value")));
+//
+//	rb_cMessage.define_method("clone", &cms::Message::clone);
+
+//	rb_cMessage.define_method("acknowledge", &cms::Message::acknowledge);
+//	rb_cMessage.define_method("clearBody", &cms::Message::clearBody);
+//	rb_cMessage.define_method("clearProperties", &cms::Message::clearProperties);
+//	rb_cMessage.define_method("propertyExists?", &cms::Message::propertyExists, (Arg("name")));
+//	rb_cMessage.define_method("propertyNames", &cms::Message::getPropertyNames);
+//
+//	rb_cMessage.define_method("destination", &cms::Message::getCMSDestination);
+//	rb_cMessage.define_method("destination=", &cms::Message::setCMSDestination, (Arg("destination")));
+//
+//	rb_cMessage.define_method("expiration", &cms::Message::getCMSExpiration);
+//	rb_cMessage.define_method("expiration=", &cms::Message::setCMSExpiration, (Arg("expireTime")));
+//
+//	rb_cMessage.define_method("message_id", &cms::Message::getCMSMessageID);
+//	rb_cMessage.define_method("message_id=", &cms::Message::setCMSMessageID, (Arg("id")));
+//
+//	rb_cMessage.define_method("priority", &cms::Message::getCMSPriority);
+//	rb_cMessage.define_method("priority=", &cms::Message::setCMSPriority, (Arg("priority")));
+//
+//	rb_cMessage.define_method("redelivered?", &cms::Message::getCMSRedelivered);
+//	rb_cMessage.define_method("redelivered=", &cms::Message::setCMSRedelivered, (Arg("redelivered")));
+//
+//	rb_cMessage.define_method("reply_to", &cms::Message::getCMSReplyTo);
+//	rb_cMessage.define_method("reply_to=", &cms::Message::setCMSReplyTo, (Arg("destination")));
+//
+//	rb_cMessage.define_method("timestamp", &cms::Message::getCMSTimestamp);
+//	rb_cMessage.define_method("timestamp=", &cms::Message::setCMSTimestamp, (Arg("timeStamp")));
+//
+//	rb_cMessage.define_method("type", &cms::Message::getCMSType);
+//	rb_cMessage.define_method("type=", &cms::Message::setCMSType, (Arg("type")));
+//
+//	rb_cMessage.define_method("correlation_id", &cms::Message::getCMSCorrelationID);
+//	rb_cMessage.define_method("correlation_id=", &cms::Message::setCMSCorrelationID, (Arg("correlationId")));
+//
+//	rb_cMessage.define_method("delivery_mode", &cms::Message::getCMSDeliveryMode);
+//	rb_cMessage.define_method("delivery_mode=", &cms::Message::setCMSDeliveryMode, (Arg("mode")));
+}

data/ext/ActiveMQ/MessageProducer.cpp

@@ -0,0 +1,42 @@
+#include "activemq.hpp"
+
+void register_MessageProducer(Module rb_module) {
+	Data_Type< cms::MessageProducer > rb_cMessageProducer =  define_class_under< cms::MessageProducer >(rb_module, "MessageProducer");
+	rb_cMessageProducer.define_method("instance?", &instance, (Arg("class")));
+
+	rb_cMessageProducer.define_method("time_to_live", &cms::MessageProducer::getTimeToLive);
+	rb_cMessageProducer.define_method("time_to_live=", &cms::MessageProducer::setTimeToLive, (Arg("time")));
+
+	rb_cMessageProducer.define_method("delivery_mode", &cms::MessageProducer::getDeliveryMode);
+	rb_cMessageProducer.define_method("delivery_mode=", &cms::MessageProducer::setDeliveryMode, (Arg("mode")));
+
+	rb_cMessageProducer.define_method("priority", &cms::MessageProducer::getPriority);
+	rb_cMessageProducer.define_method("priority=", &cms::MessageProducer::setPriority, (Arg("priority")));
+
+	rb_cMessageProducer.define_method("disable_message_time_stamp?", &cms::MessageProducer::getDisableMessageTimeStamp);
+	rb_cMessageProducer.define_method("disable_message_time_stamp=", &cms::MessageProducer::setDisableMessageTimeStamp, (Arg("value")));
+
+	rb_cMessageProducer.define_method("disable_message_id?", &cms::MessageProducer::getDisableMessageID);
+	rb_cMessageProducer.define_method("disable_message_id=", &cms::MessageProducer::setDisableMessageID, (Arg("value")));
+
+//	{
+//		typedef void ( cms::MessageProducer::*send_func_type )( cms::Message* message, int deliveryMode, int priority, long long int timeToLive );
+//		rb_cMessageProducer.define_method("send_message_with_attrs", send_func_type( &cms::MessageProducer::send ), (Arg("message"), Arg("delivery_mode"), Arg("priority"), Arg("time_to_live")));
+//	}
+
+	{
+		typedef void ( cms::MessageProducer::*send_func_type )( cms::Message* message );
+		rb_cMessageProducer.define_method("send_message", send_func_type( &cms::MessageProducer::send ), (Arg("message")));
+	}
+
+//	{
+//		typedef void ( cms::MessageProducer::*send_func_type )( const cms::Destination* destination, cms::Message* message );
+//		rb_cMessageProducer.define_method("send_message_to", send_func_type( &cms::MessageProducer::send ), (Arg("destination"), Arg("message")));
+//	}
+//
+//	{
+//		typedef void ( cms::MessageProducer::*send_func_type )( const cms::Destination* destination, cms::Message* message, int deliveryMode, int priority, long long int timeToLive );
+//		rb_cMessageProducer.define_method("send_message_to_with_attrs", send_func_type( &cms::MessageProducer::send ), (Arg("destination"), Arg("message"), Arg("deliveryMode"), Arg("priority"), Arg("timeToLive")));
+//	}
+
+}

data/ext/ActiveMQ/Session.cpp

@@ -0,0 +1,63 @@
+#include "activemq.hpp"
+
+template<>
+Rice::Object to_ruby<cms::Session::AcknowledgeMode >(cms::Session::AcknowledgeMode const & a) {
+	return Rice::Data_Object<cms::Session::AcknowledgeMode >(new cms::Session::AcknowledgeMode(a), Rice::Data_Type<cms::Session::AcknowledgeMode >::klass(), 0, 0);
+}
+
+void register_Session(Module rb_module) {
+
+//	cms::MessageConsumer* (cms::Session::*Session_createConsumer1)(const cms::Destination*) = &cms::Session::createConsumer;
+//	cms::MessageConsumer* (cms::Session::*Session_createConsumer2)(const cms::Destination*, const std::string&) = &cms::Session::createConsumer;
+//	cms::MessageConsumer* (cms::Session::*Session_createConsumer3)(const cms::Destination*, const std::string&, bool) = &cms::Session::createConsumer;
+	cms::TextMessage* (cms::Session::*Session_createTextMessage1)(const std::string&) = &cms::Session::createTextMessage;
+//	cms::BytesMessage* (cms::Session::*Session_createBytesMessage0)() = &cms::Session::createBytesMessage;
+//	cms::BytesMessage* (cms::Session::*Session_createBytesMessage2)(const unsigned char* bytes, int bytesSize) = &cms::Session::createBytesMessage;
+//	cms::QueueBrowser* (cms::Session::*Session_createBrowser1)(const cms::Queue* queue) = &cms::Session::createBrowser;
+//	cms::QueueBrowser* (cms::Session::*Session_createBrowser2)(const cms::Queue* queue, const std::string& selector) = &cms::Session::createBrowser;
+
+	Data_Type< cms::Session > rb_cSession =  define_class_under< cms::Session >(rb_module, "Session");
+	rb_cSession.define_method("instance?", &instance, (Arg("class")));
+//	rb_cSession.define_method("createBytesMessage", Session_createBytesMessage0);
+//	rb_cSession.define_method("createBytesMessage2", Session_createBytesMessage2, (Arg("bytes"), Arg("bytesSize")));
+
+	rb_cSession.define_method("create_text_message", Session_createTextMessage1, (Arg("text") = new std::string("")));
+
+	rb_cSession.define_method("create_message", &cms::Session::createMessage);
+
+//	rb_cSession.define_method("create_stream_message", &cms::Session::createStreamMessage);
+//	rb_cSession.define_method("create_map_message", &cms::Session::createMapMessage);
+
+//	rb_cSession.define_method("createConsumer", Session_createConsumer1, (Arg("destination")));
+//	rb_cSession.define_method("createConsumer2", Session_createConsumer2, (Arg("destination"), Arg("selector")));
+//	rb_cSession.define_method("createConsumer3", Session_createConsumer3, (Arg("destination"), Arg("selector"), Arg("noLocal")));
+
+//	rb_cSession.define_method("create_durable_consumer", &cms::Session::createDurableConsumer, (Arg("destination"), Arg("name"), Arg("selector"), Arg("noLocal") = (bool)(false)));
+	rb_cSession.define_method("create_producer", &cms::Session::createProducer, (Arg("destination")));
+
+	rb_cSession.define_method("create_queue", &cms::Session::createQueue, (Arg("name")));
+	rb_cSession.define_method("create_topic", &cms::Session::createTopic, (Arg("name")));
+	rb_cSession.define_method("create_temporary_queue", &cms::Session::createTemporaryQueue);
+	rb_cSession.define_method("create_temporary_topic", &cms::Session::createTemporaryTopic);
+
+	rb_cSession.define_method("acknowledge_mode", &cms::Session::getAcknowledgeMode);
+
+	rb_cSession.define_method("transacted?", &cms::Session::isTransacted);
+
+	rb_cSession.define_method("close", &cms::Session::close);
+	rb_cSession.define_method("commit", &cms::Session::commit);
+	rb_cSession.define_method("rollback", &cms::Session::rollback);
+	rb_cSession.define_method("recover", &cms::Session::recover);
+
+//	rb_cSession.define_method("unsubscribe", &cms::Session::unsubscribe, (Arg("name")));
+
+//	rb_cSession.define_method("createBrowser", Session_createBrowser1, (Arg("queue")));
+//	rb_cSession.define_method("createBrowser2", Session_createBrowser2, (Arg("queue"), Arg("selector")));
+
+	Enum<cms::Session::AcknowledgeMode> rb_eAcknowledgeMode = define_enum<cms::Session::AcknowledgeMode>("AcknowledgeMode", rb_cSession);
+
+	rb_eAcknowledgeMode.define_value("AUTO_ACKNOWLEDGE", cms::Session::AUTO_ACKNOWLEDGE);
+	rb_eAcknowledgeMode.define_value("DUPS_OK_ACKNOWLEDGE", cms::Session::DUPS_OK_ACKNOWLEDGE);
+	rb_eAcknowledgeMode.define_value("CLIENT_ACKNOWLEDGE", cms::Session::CLIENT_ACKNOWLEDGE);
+	rb_eAcknowledgeMode.define_value("SESSION_TRANSACTED", cms::Session::SESSION_TRANSACTED);
+}