svn commit: r450293 [2/3] - in /incubator/activemq/sandbox/openwire-c: openwire.xcodeproj/project.pbxproj pom.xml src/libactivemq/amqcs.c src/libactivemq/amqcs.h src/libopenwire/ow_commands_v2.c src/libopenwire/ow_commands_v2.h

[ch...@apache.org]

Modified: incubator/activemq/sandbox/openwire-c/src/libopenwire/ow_commands_v2.c
URL: http://svn.apache.org/viewvc/incubator/activemq/sandbox/openwire-c/src/libopenwire/ow_commands_v2.c?view=diff&rev=450293&r1=450292&r2=450293
==============================================================================
--- incubator/activemq/sandbox/openwire-c/src/libopenwire/ow_commands_v2.c (original)
+++ incubator/activemq/sandbox/openwire-c/src/libopenwire/ow_commands_v2.c Tue Sep 26 19:59:05 2006
@@ -30,13 +30,14 @@
 
 #define SUCCESS_CHECK( f ) { apr_status_t rc=f; if(rc!=APR_SUCCESS) return rc; }
 
-
 ow_boolean ow_is_a_LocalTransactionId(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
+
    case OW_LOCALTRANSACTIONID_TYPE:
+
       return 1;
    }
    return 0;
@@ -57,7 +58,9 @@
 {
    ow_marshal1_TransactionId(buffer, (ow_TransactionId*)object);
    ow_marshal1_long(buffer, object->value);
+
    SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId));
+
    
 	return APR_SUCCESS;
 }
@@ -65,7 +68,9 @@
 {
    ow_marshal2_TransactionId(buffer, bitbuffer, (ow_TransactionId*)object);   
    SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->value));
+
    SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
+
    
 	return APR_SUCCESS;
 }
@@ -74,2205 +79,2895 @@
 {
    ow_unmarshal_TransactionId(buffer, bitbuffer, (ow_TransactionId*)object, pool);   
    SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->value, pool));
+
    SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_PartialCommand(ow_DataStructure *object) {
+ow_boolean ow_is_a_TransactionId(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_PARTIALCOMMAND_TYPE:
-   case OW_LASTPARTIALCOMMAND_TYPE:
-      return 1;
-   }
-   return 0;
-}
 
+   case OW_LOCALTRANSACTIONID_TYPE:
 
-ow_PartialCommand *ow_PartialCommand_create(apr_pool_t *pool) 
-{
-   ow_PartialCommand *value = apr_pcalloc(pool,sizeof(ow_PartialCommand));
-   if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_PARTIALCOMMAND_TYPE;
+   case OW_XATRANSACTIONID_TYPE:
+
+      return 1;
    }
-   return value;
+   return 0;
 }
 
 
-apr_status_t ow_marshal1_PartialCommand(ow_bit_buffer *buffer, ow_PartialCommand *object)
+apr_status_t ow_marshal1_TransactionId(ow_bit_buffer *buffer, ow_TransactionId *object)
 {
    ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
    
-   
-                        ow_bit_buffer_append(buffer,  object->data!=0 );
-                        
-   
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_PartialCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_PartialCommand *object)
+apr_status_t ow_marshal2_TransactionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_TransactionId *object)
 {
    ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->commandId));
-   SUCCESS_CHECK(ow_marshal2_byte_array(buffer, bitbuffer, object->data));
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_PartialCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_PartialCommand *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_TransactionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_TransactionId *object, apr_pool_t *pool)
 {
    ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->commandId));
-   SUCCESS_CHECK(ow_unmarshal_byte_array(buffer, bitbuffer, &object->data, pool));
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_IntegerResponse(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQObjectMessage(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_INTEGERRESPONSE_TYPE:
+
+   case OW_ACTIVEMQOBJECTMESSAGE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_IntegerResponse *ow_IntegerResponse_create(apr_pool_t *pool) 
+ow_ActiveMQObjectMessage *ow_ActiveMQObjectMessage_create(apr_pool_t *pool) 
 {
-   ow_IntegerResponse *value = apr_pcalloc(pool,sizeof(ow_IntegerResponse));
+   ow_ActiveMQObjectMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQObjectMessage));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_INTEGERRESPONSE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQOBJECTMESSAGE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_IntegerResponse(ow_bit_buffer *buffer, ow_IntegerResponse *object)
+apr_status_t ow_marshal1_ActiveMQObjectMessage(ow_bit_buffer *buffer, ow_ActiveMQObjectMessage *object)
 {
-   ow_marshal1_Response(buffer, (ow_Response*)object);
-   
+   ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_IntegerResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_IntegerResponse *object)
+apr_status_t ow_marshal2_ActiveMQObjectMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object)
 {
-   ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object);   
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->result));
+   ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_IntegerResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_IntegerResponse *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQObjectMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object, apr_pool_t *pool)
 {
-   ow_unmarshal_Response(buffer, bitbuffer, (ow_Response*)object, pool);   
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->result));
+   ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ActiveMQQueue(ow_DataStructure *object) {
+ow_boolean ow_is_a_ConnectionId(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_ACTIVEMQQUEUE_TYPE:
+
+   case OW_CONNECTIONID_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ActiveMQQueue *ow_ActiveMQQueue_create(apr_pool_t *pool) 
+ow_ConnectionId *ow_ConnectionId_create(apr_pool_t *pool) 
 {
-   ow_ActiveMQQueue *value = apr_pcalloc(pool,sizeof(ow_ActiveMQQueue));
+   ow_ConnectionId *value = apr_pcalloc(pool,sizeof(ow_ConnectionId));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQQUEUE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_CONNECTIONID_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ActiveMQQueue(ow_bit_buffer *buffer, ow_ActiveMQQueue *object)
+apr_status_t ow_marshal1_ConnectionId(ow_bit_buffer *buffer, ow_ConnectionId *object)
 {
-   ow_marshal1_ActiveMQDestination(buffer, (ow_ActiveMQDestination*)object);
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   ow_marshal1_string(buffer, object->value);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ActiveMQQueue(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQQueue *object)
+apr_status_t ow_marshal2_ConnectionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *object)
 {
-   ow_marshal2_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object);   
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->value));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ActiveMQQueue(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQQueue *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ConnectionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *object, apr_pool_t *pool)
 {
-   ow_unmarshal_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object, pool);   
+   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->value, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_TransactionId(ow_DataStructure *object) {
+ow_boolean ow_is_a_SessionInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_LOCALTRANSACTIONID_TYPE:
-   case OW_XATRANSACTIONID_TYPE:
+
+   case OW_SESSIONINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-apr_status_t ow_marshal1_TransactionId(ow_bit_buffer *buffer, ow_TransactionId *object)
+ow_SessionInfo *ow_SessionInfo_create(apr_pool_t *pool) 
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   ow_SessionInfo *value = apr_pcalloc(pool,sizeof(ow_SessionInfo));
+   if( value!=0 ) {
+      ((ow_DataStructure*)value)->structType = OW_SESSIONINFO_TYPE;
+   }
+   return value;
+}
+
+
+apr_status_t ow_marshal1_SessionInfo(ow_bit_buffer *buffer, ow_SessionInfo *object)
+{
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->sessionId));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_TransactionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_TransactionId *object)
+apr_status_t ow_marshal2_SessionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->sessionId));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_TransactionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_TransactionId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_SessionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->sessionId, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ActiveMQObjectMessage(ow_DataStructure *object) {
+ow_boolean ow_is_a_TransactionInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_ACTIVEMQOBJECTMESSAGE_TYPE:
+
+   case OW_TRANSACTIONINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ActiveMQObjectMessage *ow_ActiveMQObjectMessage_create(apr_pool_t *pool) 
+ow_TransactionInfo *ow_TransactionInfo_create(apr_pool_t *pool) 
 {
-   ow_ActiveMQObjectMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQObjectMessage));
+   ow_TransactionInfo *value = apr_pcalloc(pool,sizeof(ow_TransactionInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQOBJECTMESSAGE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_TRANSACTIONINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ActiveMQObjectMessage(ow_bit_buffer *buffer, ow_ActiveMQObjectMessage *object)
+apr_status_t ow_marshal1_TransactionInfo(ow_bit_buffer *buffer, ow_TransactionInfo *object)
 {
-   ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object);
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId));
+
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->transactionId));
+
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ActiveMQObjectMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object)
+apr_status_t ow_marshal2_TransactionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *object)
 {
-   ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object);   
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
+
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId));
+
+   SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->type));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ActiveMQObjectMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_TransactionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *object, apr_pool_t *pool)
 {
-   ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool);   
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool));
+
+   SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->type));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ConnectionId(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQStreamMessage(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_CONNECTIONID_TYPE:
+
+   case OW_ACTIVEMQSTREAMMESSAGE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ConnectionId *ow_ConnectionId_create(apr_pool_t *pool) 
+ow_ActiveMQStreamMessage *ow_ActiveMQStreamMessage_create(apr_pool_t *pool) 
 {
-   ow_ConnectionId *value = apr_pcalloc(pool,sizeof(ow_ConnectionId));
+   ow_ActiveMQStreamMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQStreamMessage));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONNECTIONID_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQSTREAMMESSAGE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ConnectionId(ow_bit_buffer *buffer, ow_ConnectionId *object)
+apr_status_t ow_marshal1_ActiveMQStreamMessage(ow_bit_buffer *buffer, ow_ActiveMQStreamMessage *object)
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->value);
+   ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ConnectionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *object)
+apr_status_t ow_marshal2_ActiveMQStreamMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->value));
+   ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ConnectionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQStreamMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->value, pool));
+   ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ConnectionInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_RemoveSubscriptionInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_CONNECTIONINFO_TYPE:
+
+   case OW_REMOVESUBSCRIPTIONINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ConnectionInfo *ow_ConnectionInfo_create(apr_pool_t *pool) 
+ow_RemoveSubscriptionInfo *ow_RemoveSubscriptionInfo_create(apr_pool_t *pool) 
 {
-   ow_ConnectionInfo *value = apr_pcalloc(pool,sizeof(ow_ConnectionInfo));
+   ow_RemoveSubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_RemoveSubscriptionInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONNECTIONINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_REMOVESUBSCRIPTIONINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ConnectionInfo(ow_bit_buffer *buffer, ow_ConnectionInfo *object)
+apr_status_t ow_marshal1_RemoveSubscriptionInfo(ow_bit_buffer *buffer, ow_RemoveSubscriptionInfo *object)
 {
    ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
    SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId));
+
+   ow_marshal1_string(buffer, object->subcriptionName);
+
    ow_marshal1_string(buffer, object->clientId);
-   ow_marshal1_string(buffer, object->password);
-   ow_marshal1_string(buffer, object->userName);
-   SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->brokerPath));
-   ow_bit_buffer_append(buffer, object->brokerMasterConnector);
-   ow_bit_buffer_append(buffer, object->manageable);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ConnectionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionInfo *object)
+apr_status_t ow_marshal2_RemoveSubscriptionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_RemoveSubscriptionInfo *object)
 {
    ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
    SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->subcriptionName));
+
    SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->clientId));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->password));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->userName));
-   SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->brokerPath));
-   ow_bit_buffer_read(bitbuffer);
-   ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ConnectionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_RemoveSubscriptionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_RemoveSubscriptionInfo *object, apr_pool_t *pool)
 {
    ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
    SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->subcriptionName, pool));
+
    SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->clientId, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->password, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->userName, pool));
-   SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->brokerPath, pool));
-   object->brokerMasterConnector = ow_bit_buffer_read(bitbuffer);
-   object->manageable = ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ProducerInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_Response(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_PRODUCERINFO_TYPE:
+
+   case OW_RESPONSE_TYPE:
+
+   case OW_DATARESPONSE_TYPE:
+
+   case OW_EXCEPTIONRESPONSE_TYPE:
+
+   case OW_INTEGERRESPONSE_TYPE:
+
+   case OW_DATAARRAYRESPONSE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ProducerInfo *ow_ProducerInfo_create(apr_pool_t *pool) 
+ow_Response *ow_Response_create(apr_pool_t *pool) 
 {
-   ow_ProducerInfo *value = apr_pcalloc(pool,sizeof(ow_ProducerInfo));
+   ow_Response *value = apr_pcalloc(pool,sizeof(ow_Response));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_PRODUCERINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_RESPONSE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ProducerInfo(ow_bit_buffer *buffer, ow_ProducerInfo *object)
+apr_status_t ow_marshal1_Response(ow_bit_buffer *buffer, ow_Response *object)
 {
    ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->producerId));
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->brokerPath));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ProducerInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ProducerInfo *object)
+apr_status_t ow_marshal2_Response(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_Response *object)
 {
    ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->producerId));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->brokerPath));
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->correlationId));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ProducerInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ProducerInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_Response(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_Response *object, apr_pool_t *pool)
 {
    ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->producerId, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->brokerPath, pool));
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->correlationId));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_MessageDispatchNotification(ow_DataStructure *object) {
+ow_boolean ow_is_a_ConnectionError(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_MESSAGEDISPATCHNOTIFICATION_TYPE:
+
+   case OW_CONNECTIONERROR_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_MessageDispatchNotification *ow_MessageDispatchNotification_create(apr_pool_t *pool) 
+ow_ConnectionError *ow_ConnectionError_create(apr_pool_t *pool) 
 {
-   ow_MessageDispatchNotification *value = apr_pcalloc(pool,sizeof(ow_MessageDispatchNotification));
+   ow_ConnectionError *value = apr_pcalloc(pool,sizeof(ow_ConnectionError));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_MESSAGEDISPATCHNOTIFICATION_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_CONNECTIONERROR_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_MessageDispatchNotification(ow_bit_buffer *buffer, ow_MessageDispatchNotification *object)
+apr_status_t ow_marshal1_ConnectionError(ow_bit_buffer *buffer, ow_ConnectionError *object)
 {
    ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->consumerId));
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
-   ow_marshal1_long(buffer, object->deliverySequenceId);
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->messageId));
+   SUCCESS_CHECK(ow_marshal1_throwable(buffer, object->exception));
+
+   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->connectionId));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_MessageDispatchNotification(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageDispatchNotification *object)
+apr_status_t ow_marshal2_ConnectionError(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionError *object)
 {
    ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->consumerId));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->deliverySequenceId));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->messageId));
+   SUCCESS_CHECK(ow_marshal2_throwable(buffer, bitbuffer, object->exception));
+
+   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_MessageDispatchNotification(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageDispatchNotification *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ConnectionError(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionError *object, apr_pool_t *pool)
 {
    ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->consumerId, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->deliverySequenceId, pool));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->messageId, pool));
+   SUCCESS_CHECK(ow_unmarshal_throwable(buffer, bitbuffer, &object->exception, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_SessionInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_SubscriptionInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_SESSIONINFO_TYPE:
+
+   case OW_SUBSCRIPTIONINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_SessionInfo *ow_SessionInfo_create(apr_pool_t *pool) 
+ow_SubscriptionInfo *ow_SubscriptionInfo_create(apr_pool_t *pool) 
 {
-   ow_SessionInfo *value = apr_pcalloc(pool,sizeof(ow_SessionInfo));
+   ow_SubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_SubscriptionInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_SESSIONINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_SUBSCRIPTIONINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_SessionInfo(ow_bit_buffer *buffer, ow_SessionInfo *object)
+apr_status_t ow_marshal1_SubscriptionInfo(ow_bit_buffer *buffer, ow_SubscriptionInfo *object)
 {
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->sessionId));
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   ow_marshal1_string(buffer, object->clientId);
+
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
+
+   ow_marshal1_string(buffer, object->selector);
+
+   ow_marshal1_string(buffer, object->subcriptionName);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_SessionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *object)
+apr_status_t ow_marshal2_SubscriptionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *object)
 {
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->sessionId));
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->clientId));
+
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->selector));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->subcriptionName));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_SessionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_SubscriptionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *object, apr_pool_t *pool)
 {
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->sessionId, pool));
+   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->clientId, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->selector, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->subcriptionName, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_TransactionInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_JournalTransaction(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_TRANSACTIONINFO_TYPE:
+
+   case OW_JOURNALTRANSACTION_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_TransactionInfo *ow_TransactionInfo_create(apr_pool_t *pool) 
+ow_JournalTransaction *ow_JournalTransaction_create(apr_pool_t *pool) 
 {
-   ow_TransactionInfo *value = apr_pcalloc(pool,sizeof(ow_TransactionInfo));
+   ow_JournalTransaction *value = apr_pcalloc(pool,sizeof(ow_JournalTransaction));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_TRANSACTIONINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_JOURNALTRANSACTION_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_TransactionInfo(ow_bit_buffer *buffer, ow_TransactionInfo *object)
+apr_status_t ow_marshal1_JournalTransaction(ow_bit_buffer *buffer, ow_JournalTransaction *object)
 {
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId));
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->transactionId));
-   
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->transactionId));
+
+
+   ow_bit_buffer_append(buffer, object->wasPrepared);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_TransactionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *object)
+apr_status_t ow_marshal2_JournalTransaction(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *object)
 {
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId));
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId));
+
    SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->type));
+
+   ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_TransactionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_JournalTransaction(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *object, apr_pool_t *pool)
 {
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool));
+   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool));
+
    SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->type));
+
+   object->wasPrepared = ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ActiveMQStreamMessage(ow_DataStructure *object) {
+ow_boolean ow_is_a_ControlCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_ACTIVEMQSTREAMMESSAGE_TYPE:
+
+   case OW_CONTROLCOMMAND_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ActiveMQStreamMessage *ow_ActiveMQStreamMessage_create(apr_pool_t *pool) 
+ow_ControlCommand *ow_ControlCommand_create(apr_pool_t *pool) 
 {
-   ow_ActiveMQStreamMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQStreamMessage));
+   ow_ControlCommand *value = apr_pcalloc(pool,sizeof(ow_ControlCommand));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQSTREAMMESSAGE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_CONTROLCOMMAND_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ActiveMQStreamMessage(ow_bit_buffer *buffer, ow_ActiveMQStreamMessage *object)
+apr_status_t ow_marshal1_ControlCommand(ow_bit_buffer *buffer, ow_ControlCommand *object)
 {
-   ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object);
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
+   ow_marshal1_string(buffer, object->command);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ActiveMQStreamMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object)
+apr_status_t ow_marshal2_ControlCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *object)
 {
-   ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object);   
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->command));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ActiveMQStreamMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ControlCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *object, apr_pool_t *pool)
 {
-   ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool);   
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->command, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_MessageAck(ow_DataStructure *object) {
+ow_boolean ow_is_a_LastPartialCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_MESSAGEACK_TYPE:
+
+   case OW_LASTPARTIALCOMMAND_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_MessageAck *ow_MessageAck_create(apr_pool_t *pool) 
+ow_LastPartialCommand *ow_LastPartialCommand_create(apr_pool_t *pool) 
 {
-   ow_MessageAck *value = apr_pcalloc(pool,sizeof(ow_MessageAck));
+   ow_LastPartialCommand *value = apr_pcalloc(pool,sizeof(ow_LastPartialCommand));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_MESSAGEACK_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_LASTPARTIALCOMMAND_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_MessageAck(ow_bit_buffer *buffer, ow_MessageAck *object)
+apr_status_t ow_marshal1_LastPartialCommand(ow_bit_buffer *buffer, ow_LastPartialCommand *object)
 {
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->transactionId));
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->consumerId));
-   
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->firstMessageId));
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->lastMessageId));
-   
+   ow_marshal1_PartialCommand(buffer, (ow_PartialCommand*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_MessageAck(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageAck *object)
+apr_status_t ow_marshal2_LastPartialCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_LastPartialCommand *object)
 {
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->consumerId));
-   SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->ackType));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->firstMessageId));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->lastMessageId));
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->messageCount));
+   ow_marshal2_PartialCommand(buffer, bitbuffer, (ow_PartialCommand*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_MessageAck(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageAck *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_LastPartialCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_LastPartialCommand *object, apr_pool_t *pool)
 {
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->consumerId, pool));
-   SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->ackType));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->firstMessageId, pool));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->lastMessageId, pool));
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->messageCount));
+   ow_unmarshal_PartialCommand(buffer, bitbuffer, (ow_PartialCommand*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ProducerId(ow_DataStructure *object) {
+ow_boolean ow_is_a_NetworkBridgeFilter(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_PRODUCERID_TYPE:
+
+   case OW_NETWORKBRIDGEFILTER_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ProducerId *ow_ProducerId_create(apr_pool_t *pool) 
+ow_NetworkBridgeFilter *ow_NetworkBridgeFilter_create(apr_pool_t *pool) 
 {
-   ow_ProducerId *value = apr_pcalloc(pool,sizeof(ow_ProducerId));
+   ow_NetworkBridgeFilter *value = apr_pcalloc(pool,sizeof(ow_NetworkBridgeFilter));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_PRODUCERID_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_NETWORKBRIDGEFILTER_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ProducerId(ow_bit_buffer *buffer, ow_ProducerId *object)
+apr_status_t ow_marshal1_NetworkBridgeFilter(ow_bit_buffer *buffer, ow_NetworkBridgeFilter *object)
 {
    ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->connectionId);
-   ow_marshal1_long(buffer, object->value);
-   ow_marshal1_long(buffer, object->sessionId);
+
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->networkBrokerId));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ProducerId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ProducerId *object)
+apr_status_t ow_marshal2_NetworkBridgeFilter(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_NetworkBridgeFilter *object)
 {
    ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->connectionId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->value));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->sessionId));
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->networkTTL));
+
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->networkBrokerId));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ProducerId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ProducerId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_NetworkBridgeFilter(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_NetworkBridgeFilter *object, apr_pool_t *pool)
 {
    ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->connectionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->value, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->sessionId, pool));
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->networkTTL));
+
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->networkBrokerId, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_MessageId(ow_DataStructure *object) {
+ow_boolean ow_is_a_WireFormatInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_MESSAGEID_TYPE:
+
+   case OW_WIREFORMATINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_MessageId *ow_MessageId_create(apr_pool_t *pool) 
+ow_WireFormatInfo *ow_WireFormatInfo_create(apr_pool_t *pool) 
 {
-   ow_MessageId *value = apr_pcalloc(pool,sizeof(ow_MessageId));
+   ow_WireFormatInfo *value = apr_pcalloc(pool,sizeof(ow_WireFormatInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_MESSAGEID_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_WIREFORMATINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_MessageId(ow_bit_buffer *buffer, ow_MessageId *object)
+apr_status_t ow_marshal1_WireFormatInfo(ow_bit_buffer *buffer, ow_WireFormatInfo *object)
 {
    ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->producerId));
-   ow_marshal1_long(buffer, object->producerSequenceId);
-   ow_marshal1_long(buffer, object->brokerSequenceId);
+
+
+   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->marshalledProperties));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_MessageId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageId *object)
+apr_status_t ow_marshal2_WireFormatInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_WireFormatInfo *object)
 {
    ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->producerId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->producerSequenceId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->brokerSequenceId));
+   SUCCESS_CHECK(ow_marshal2_byte_array_const_size(buffer, object->magic, 8));
+
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->version));
+
+   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->marshalledProperties));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_MessageId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_WireFormatInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_WireFormatInfo *object, apr_pool_t *pool)
 {
    ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->producerId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->producerSequenceId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->brokerSequenceId, pool));
+   SUCCESS_CHECK(ow_unmarshal_byte_array_const_size(buffer, &object->magic, 8, pool));
+
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->version));
+
+   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->marshalledProperties, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ActiveMQTempQueue(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQTempTopic(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_ACTIVEMQTEMPQUEUE_TYPE:
+
+   case OW_ACTIVEMQTEMPTOPIC_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ActiveMQTempQueue *ow_ActiveMQTempQueue_create(apr_pool_t *pool) 
+ow_ActiveMQTempTopic *ow_ActiveMQTempTopic_create(apr_pool_t *pool) 
 {
-   ow_ActiveMQTempQueue *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTempQueue));
+   ow_ActiveMQTempTopic *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTempTopic));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEMPQUEUE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEMPTOPIC_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ActiveMQTempQueue(ow_bit_buffer *buffer, ow_ActiveMQTempQueue *object)
+apr_status_t ow_marshal1_ActiveMQTempTopic(ow_bit_buffer *buffer, ow_ActiveMQTempTopic *object)
 {
    ow_marshal1_ActiveMQTempDestination(buffer, (ow_ActiveMQTempDestination*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ActiveMQTempQueue(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempQueue *object)
+apr_status_t ow_marshal2_ActiveMQTempTopic(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempTopic *object)
 {
    ow_marshal2_ActiveMQTempDestination(buffer, bitbuffer, (ow_ActiveMQTempDestination*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ActiveMQTempQueue(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempQueue *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQTempTopic(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempTopic *object, apr_pool_t *pool)
 {
    ow_unmarshal_ActiveMQTempDestination(buffer, bitbuffer, (ow_ActiveMQTempDestination*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_RemoveSubscriptionInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_DiscoveryEvent(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_REMOVESUBSCRIPTIONINFO_TYPE:
+
+   case OW_DISCOVERYEVENT_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_RemoveSubscriptionInfo *ow_RemoveSubscriptionInfo_create(apr_pool_t *pool) 
+ow_DiscoveryEvent *ow_DiscoveryEvent_create(apr_pool_t *pool) 
 {
-   ow_RemoveSubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_RemoveSubscriptionInfo));
+   ow_DiscoveryEvent *value = apr_pcalloc(pool,sizeof(ow_DiscoveryEvent));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_REMOVESUBSCRIPTIONINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_DISCOVERYEVENT_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_RemoveSubscriptionInfo(ow_bit_buffer *buffer, ow_RemoveSubscriptionInfo *object)
+apr_status_t ow_marshal1_DiscoveryEvent(ow_bit_buffer *buffer, ow_DiscoveryEvent *object)
 {
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId));
-   ow_marshal1_string(buffer, object->subcriptionName);
-   ow_marshal1_string(buffer, object->clientId);
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   ow_marshal1_string(buffer, object->serviceName);
+
+   ow_marshal1_string(buffer, object->brokerName);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_RemoveSubscriptionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_RemoveSubscriptionInfo *object)
+apr_status_t ow_marshal2_DiscoveryEvent(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DiscoveryEvent *object)
 {
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->subcriptionName));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->clientId));
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->serviceName));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->brokerName));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_RemoveSubscriptionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_RemoveSubscriptionInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_DiscoveryEvent(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DiscoveryEvent *object, apr_pool_t *pool)
 {
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->subcriptionName, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->clientId, pool));
+   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->serviceName, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->brokerName, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_SessionId(ow_DataStructure *object) {
+ow_boolean ow_is_a_ReplayCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_SESSIONID_TYPE:
+
+   case OW_REPLAYCOMMAND_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_SessionId *ow_SessionId_create(apr_pool_t *pool) 
+ow_ReplayCommand *ow_ReplayCommand_create(apr_pool_t *pool) 
 {
-   ow_SessionId *value = apr_pcalloc(pool,sizeof(ow_SessionId));
+   ow_ReplayCommand *value = apr_pcalloc(pool,sizeof(ow_ReplayCommand));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_SESSIONID_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_REPLAYCOMMAND_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_SessionId(ow_bit_buffer *buffer, ow_SessionId *object)
+apr_status_t ow_marshal1_ReplayCommand(ow_bit_buffer *buffer, ow_ReplayCommand *object)
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->connectionId);
-   ow_marshal1_long(buffer, object->value);
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
+
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_SessionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SessionId *object)
+apr_status_t ow_marshal2_ReplayCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ReplayCommand *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->connectionId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->value));
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->firstNakNumber));
+
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->lastNakNumber));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_SessionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SessionId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ReplayCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ReplayCommand *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->connectionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->value, pool));
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->firstNakNumber));
+
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->lastNakNumber));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_DataArrayResponse(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQDestination(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_DATAARRAYRESPONSE_TYPE:
+
+   case OW_ACTIVEMQTEMPTOPIC_TYPE:
+
+   case OW_ACTIVEMQTOPIC_TYPE:
+
+   case OW_ACTIVEMQQUEUE_TYPE:
+
+   case OW_ACTIVEMQTEMPQUEUE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_DataArrayResponse *ow_DataArrayResponse_create(apr_pool_t *pool) 
+apr_status_t ow_marshal1_ActiveMQDestination(ow_bit_buffer *buffer, ow_ActiveMQDestination *object)
 {
-   ow_DataArrayResponse *value = apr_pcalloc(pool,sizeof(ow_DataArrayResponse));
-   if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_DATAARRAYRESPONSE_TYPE;
-   }
-   return value;
-}
-
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+   ow_marshal1_string(buffer, object->physicalName);
 
-apr_status_t ow_marshal1_DataArrayResponse(ow_bit_buffer *buffer, ow_DataArrayResponse *object)
-{
-   ow_marshal1_Response(buffer, (ow_Response*)object);
-   SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->data));
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_DataArrayResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DataArrayResponse *object)
+apr_status_t ow_marshal2_ActiveMQDestination(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQDestination *object)
 {
-   ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object);   
-   SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->data));
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->physicalName));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_DataArrayResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DataArrayResponse *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQDestination(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQDestination *object, apr_pool_t *pool)
 {
-   ow_unmarshal_Response(buffer, bitbuffer, (ow_Response*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->data, pool));
+   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->physicalName, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_JournalQueueAck(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQTopic(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_JOURNALQUEUEACK_TYPE:
+
+   case OW_ACTIVEMQTOPIC_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_JournalQueueAck *ow_JournalQueueAck_create(apr_pool_t *pool) 
+ow_ActiveMQTopic *ow_ActiveMQTopic_create(apr_pool_t *pool) 
 {
-   ow_JournalQueueAck *value = apr_pcalloc(pool,sizeof(ow_JournalQueueAck));
+   ow_ActiveMQTopic *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTopic));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_JOURNALQUEUEACK_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTOPIC_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_JournalQueueAck(ow_bit_buffer *buffer, ow_JournalQueueAck *object)
+apr_status_t ow_marshal1_ActiveMQTopic(ow_bit_buffer *buffer, ow_ActiveMQTopic *object)
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->messageAck));
+   ow_marshal1_ActiveMQDestination(buffer, (ow_ActiveMQDestination*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_JournalQueueAck(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalQueueAck *object)
+apr_status_t ow_marshal2_ActiveMQTopic(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTopic *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->messageAck));
+   ow_marshal2_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_JournalQueueAck(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalQueueAck *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQTopic(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTopic *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->messageAck, pool));
+   ow_unmarshal_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_Response(ow_DataStructure *object) {
+ow_boolean ow_is_a_BrokerInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_INTEGERRESPONSE_TYPE:
-   case OW_DATAARRAYRESPONSE_TYPE:
-   case OW_RESPONSE_TYPE:
-   case OW_DATARESPONSE_TYPE:
-   case OW_EXCEPTIONRESPONSE_TYPE:
+
+   case OW_BROKERINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_Response *ow_Response_create(apr_pool_t *pool) 
+ow_BrokerInfo *ow_BrokerInfo_create(apr_pool_t *pool) 
 {
-   ow_Response *value = apr_pcalloc(pool,sizeof(ow_Response));
+   ow_BrokerInfo *value = apr_pcalloc(pool,sizeof(ow_BrokerInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_RESPONSE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_BROKERINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_Response(ow_bit_buffer *buffer, ow_Response *object)
+apr_status_t ow_marshal1_BrokerInfo(ow_bit_buffer *buffer, ow_BrokerInfo *object)
 {
    ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   
-   
-	return APR_SUCCESS;
-}
-apr_status_t ow_marshal2_Response(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_Response *object)
-{
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->correlationId));
-   
-	return APR_SUCCESS;
-}
+   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->brokerId));
 
-apr_status_t ow_unmarshal_Response(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_Response *object, apr_pool_t *pool)
-{
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->correlationId));
-   
-	return APR_SUCCESS;
-}
+   ow_marshal1_string(buffer, object->brokerURL);
 
-ow_boolean ow_is_a_ConnectionError(ow_DataStructure *object) {
-   if( object == 0 )
-      return 0;
-      
-   switch(object->structType) {
-   case OW_CONNECTIONERROR_TYPE:
-      return 1;
-   }
-   return 0;
-}
+   SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->peerBrokerInfos));
 
+   ow_marshal1_string(buffer, object->brokerName);
 
-ow_ConnectionError *ow_ConnectionError_create(apr_pool_t *pool) 
-{
-   ow_ConnectionError *value = apr_pcalloc(pool,sizeof(ow_ConnectionError));
-   if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONNECTIONERROR_TYPE;
-   }
-   return value;
-}
+   ow_bit_buffer_append(buffer, object->slaveBroker);
 
+   ow_bit_buffer_append(buffer, object->masterBroker);
+
+   ow_bit_buffer_append(buffer, object->faultTolerantConfiguration);
 
-apr_status_t ow_marshal1_ConnectionError(ow_bit_buffer *buffer, ow_ConnectionError *object)
-{
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_throwable(buffer, object->exception));
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->connectionId));
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ConnectionError(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionError *object)
+apr_status_t ow_marshal2_BrokerInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_BrokerInfo *object)
 {
    ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_throwable(buffer, bitbuffer, object->exception));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->connectionId));
+   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->brokerId));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->brokerURL));
+
+   SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->peerBrokerInfos));
+
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->brokerName));
+
+   ow_bit_buffer_read(bitbuffer);
+
+   ow_bit_buffer_read(bitbuffer);
+
+   ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ConnectionError(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionError *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_BrokerInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_BrokerInfo *object, apr_pool_t *pool)
 {
    ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_throwable(buffer, bitbuffer, &object->exception, pool));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->connectionId, pool));
+   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->brokerId, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->brokerURL, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->peerBrokerInfos, pool));
+
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->brokerName, pool));
+
+   object->slaveBroker = ow_bit_buffer_read(bitbuffer);
+
+   object->masterBroker = ow_bit_buffer_read(bitbuffer);
+
+   object->faultTolerantConfiguration = ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ConsumerInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_ShutdownInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_CONSUMERINFO_TYPE:
+
+   case OW_SHUTDOWNINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ConsumerInfo *ow_ConsumerInfo_create(apr_pool_t *pool) 
+ow_ShutdownInfo *ow_ShutdownInfo_create(apr_pool_t *pool) 
 {
-   ow_ConsumerInfo *value = apr_pcalloc(pool,sizeof(ow_ConsumerInfo));
+   ow_ShutdownInfo *value = apr_pcalloc(pool,sizeof(ow_ShutdownInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONSUMERINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_SHUTDOWNINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ConsumerInfo(ow_bit_buffer *buffer, ow_ConsumerInfo *object)
+apr_status_t ow_marshal1_ShutdownInfo(ow_bit_buffer *buffer, ow_ShutdownInfo *object)
 {
    ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->consumerId));
-   ow_bit_buffer_append(buffer, object->browser);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
-   
-   
-   ow_bit_buffer_append(buffer, object->dispatchAsync);
-   ow_marshal1_string(buffer, object->selector);
-   ow_marshal1_string(buffer, object->subcriptionName);
-   ow_bit_buffer_append(buffer, object->noLocal);
-   ow_bit_buffer_append(buffer, object->exclusive);
-   ow_bit_buffer_append(buffer, object->retroactive);
-   
-   SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->brokerPath));
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->additionalPredicate));
-   ow_bit_buffer_append(buffer, object->networkSubscription);
-   ow_bit_buffer_append(buffer, object->optimizedAcknowledge);
-   ow_bit_buffer_append(buffer, object->noRangeAcks);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ConsumerInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerInfo *object)
+apr_status_t ow_marshal2_ShutdownInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ShutdownInfo *object)
 {
    ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->consumerId));
-   ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->prefetchSize));
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->maximumPendingMessageLimit));
-   ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->selector));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->subcriptionName));
-   ow_bit_buffer_read(bitbuffer);
-   ow_bit_buffer_read(bitbuffer);
-   ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->priority));
-   SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->brokerPath));
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->additionalPredicate));
-   ow_bit_buffer_read(bitbuffer);
-   ow_bit_buffer_read(bitbuffer);
-   ow_bit_buffer_read(bitbuffer);
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ConsumerInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ShutdownInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ShutdownInfo *object, apr_pool_t *pool)
 {
    ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->consumerId, pool));
-   object->browser = ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->prefetchSize));
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->maximumPendingMessageLimit));
-   object->dispatchAsync = ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->selector, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->subcriptionName, pool));
-   object->noLocal = ow_bit_buffer_read(bitbuffer);
-   object->exclusive = ow_bit_buffer_read(bitbuffer);
-   object->retroactive = ow_bit_buffer_read(bitbuffer);
-   SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->priority));
-   SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->brokerPath, pool));
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->additionalPredicate, pool));
-   object->networkSubscription = ow_bit_buffer_read(bitbuffer);
-   object->optimizedAcknowledge = ow_bit_buffer_read(bitbuffer);
-   object->noRangeAcks = ow_bit_buffer_read(bitbuffer);
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_XATransactionId(ow_DataStructure *object) {
+ow_boolean ow_is_a_DataResponse(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_XATRANSACTIONID_TYPE:
+
+   case OW_DATARESPONSE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_XATransactionId *ow_XATransactionId_create(apr_pool_t *pool) 
+ow_DataResponse *ow_DataResponse_create(apr_pool_t *pool) 
 {
-   ow_XATransactionId *value = apr_pcalloc(pool,sizeof(ow_XATransactionId));
+   ow_DataResponse *value = apr_pcalloc(pool,sizeof(ow_DataResponse));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_XATRANSACTIONID_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_DATARESPONSE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_XATransactionId(ow_bit_buffer *buffer, ow_XATransactionId *object)
+apr_status_t ow_marshal1_DataResponse(ow_bit_buffer *buffer, ow_DataResponse *object)
 {
-   ow_marshal1_TransactionId(buffer, (ow_TransactionId*)object);
-   
-   
-                        ow_bit_buffer_append(buffer,  object->globalTransactionId!=0 );
-                        
-   
-                        ow_bit_buffer_append(buffer,  object->branchQualifier!=0 );
-                        
+   ow_marshal1_Response(buffer, (ow_Response*)object);
+   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->data));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_XATransactionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_XATransactionId *object)
+apr_status_t ow_marshal2_DataResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DataResponse *object)
 {
-   ow_marshal2_TransactionId(buffer, bitbuffer, (ow_TransactionId*)object);   
-   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->formatId));
-   SUCCESS_CHECK(ow_marshal2_byte_array(buffer, bitbuffer, object->globalTransactionId));
-   SUCCESS_CHECK(ow_marshal2_byte_array(buffer, bitbuffer, object->branchQualifier));
+   ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object);   
+   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->data));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_XATransactionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_XATransactionId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_DataResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DataResponse *object, apr_pool_t *pool)
 {
-   ow_unmarshal_TransactionId(buffer, bitbuffer, (ow_TransactionId*)object, pool);   
-   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->formatId));
-   SUCCESS_CHECK(ow_unmarshal_byte_array(buffer, bitbuffer, &object->globalTransactionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_byte_array(buffer, bitbuffer, &object->branchQualifier, pool));
+   ow_unmarshal_Response(buffer, bitbuffer, (ow_Response*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->data, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_JournalTrace(ow_DataStructure *object) {
+ow_boolean ow_is_a_KeepAliveInfo(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_JOURNALTRACE_TYPE:
+
+   case OW_KEEPALIVEINFO_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_JournalTrace *ow_JournalTrace_create(apr_pool_t *pool) 
+ow_KeepAliveInfo *ow_KeepAliveInfo_create(apr_pool_t *pool) 
 {
-   ow_JournalTrace *value = apr_pcalloc(pool,sizeof(ow_JournalTrace));
+   ow_KeepAliveInfo *value = apr_pcalloc(pool,sizeof(ow_KeepAliveInfo));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_JOURNALTRACE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_KEEPALIVEINFO_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_JournalTrace(ow_bit_buffer *buffer, ow_JournalTrace *object)
+apr_status_t ow_marshal1_KeepAliveInfo(ow_bit_buffer *buffer, ow_KeepAliveInfo *object)
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->message);
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_JournalTrace(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalTrace *object)
+apr_status_t ow_marshal2_KeepAliveInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_KeepAliveInfo *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->message));
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_JournalTrace(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalTrace *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_KeepAliveInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_KeepAliveInfo *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->message, pool));
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ConsumerId(ow_DataStructure *object) {
+ow_boolean ow_is_a_BaseCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_CONSUMERID_TYPE:
-      return 1;
-   }
-   return 0;
-}
 
+   case OW_ACTIVEMQOBJECTMESSAGE_TYPE:
 
-ow_ConsumerId *ow_ConsumerId_create(apr_pool_t *pool) 
-{
-   ow_ConsumerId *value = apr_pcalloc(pool,sizeof(ow_ConsumerId));
-   if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONSUMERID_TYPE;
+   case OW_SESSIONINFO_TYPE:
+
+   case OW_TRANSACTIONINFO_TYPE:
+
+   case OW_ACTIVEMQSTREAMMESSAGE_TYPE:
+
+   case OW_REMOVESUBSCRIPTIONINFO_TYPE:
+
+   case OW_RESPONSE_TYPE:
+
+   case OW_CONNECTIONERROR_TYPE:
+
+   case OW_CONTROLCOMMAND_TYPE:
+
+   case OW_REPLAYCOMMAND_TYPE:
+
+   case OW_BROKERINFO_TYPE:
+
+   case OW_SHUTDOWNINFO_TYPE:
+
+   case OW_DATARESPONSE_TYPE:
+
+   case OW_KEEPALIVEINFO_TYPE:
+
+   case OW_FLUSHCOMMAND_TYPE:
+
+   case OW_ACTIVEMQMESSAGE_TYPE:
+
+   case OW_EXCEPTIONRESPONSE_TYPE:
+
+   case OW_INTEGERRESPONSE_TYPE:
+
+   case OW_CONNECTIONINFO_TYPE:
+
+   case OW_PRODUCERINFO_TYPE:
+
+   case OW_MESSAGEDISPATCHNOTIFICATION_TYPE:
+
+   case OW_MESSAGEACK_TYPE:
+
+   case OW_DATAARRAYRESPONSE_TYPE:
+
+   case OW_CONSUMERINFO_TYPE:
+
+   case OW_ACTIVEMQTEXTMESSAGE_TYPE:
+
+   case OW_MESSAGEPULL_TYPE:
+
+   case OW_ACTIVEMQBYTESMESSAGE_TYPE:
+
+   case OW_DESTINATIONINFO_TYPE:
+
+   case OW_CONNECTIONCONTROL_TYPE:
+
+   case OW_CONSUMERCONTROL_TYPE:
+
+   case OW_MESSAGEDISPATCH_TYPE:
+
+   case OW_ACTIVEMQMAPMESSAGE_TYPE:
+
+   case OW_REMOVEINFO_TYPE:
+
+      return 1;
    }
-   return value;
+   return 0;
 }
 
 
-apr_status_t ow_marshal1_ConsumerId(ow_bit_buffer *buffer, ow_ConsumerId *object)
+apr_status_t ow_marshal1_BaseCommand(ow_bit_buffer *buffer, ow_BaseCommand *object)
 {
    ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->connectionId);
-   ow_marshal1_long(buffer, object->sessionId);
-   ow_marshal1_long(buffer, object->value);
+
+   ow_bit_buffer_append(buffer, object->responseRequired);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ConsumerId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerId *object)
+apr_status_t ow_marshal2_BaseCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_BaseCommand *object)
 {
    ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->connectionId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->sessionId));
-   SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->value));
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->commandId));
+
+   ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ConsumerId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerId *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_BaseCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_BaseCommand *object, apr_pool_t *pool)
 {
    ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->connectionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->sessionId, pool));
-   SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->value, pool));
+   SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->commandId));
+
+   object->responseRequired = ow_bit_buffer_read(bitbuffer);
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ActiveMQTextMessage(ow_DataStructure *object) {
+ow_boolean ow_is_a_FlushCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_ACTIVEMQTEXTMESSAGE_TYPE:
+
+   case OW_FLUSHCOMMAND_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ActiveMQTextMessage *ow_ActiveMQTextMessage_create(apr_pool_t *pool) 
+ow_FlushCommand *ow_FlushCommand_create(apr_pool_t *pool) 
 {
-   ow_ActiveMQTextMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTextMessage));
+   ow_FlushCommand *value = apr_pcalloc(pool,sizeof(ow_FlushCommand));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEXTMESSAGE_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_FLUSHCOMMAND_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ActiveMQTextMessage(ow_bit_buffer *buffer, ow_ActiveMQTextMessage *object)
+apr_status_t ow_marshal1_FlushCommand(ow_bit_buffer *buffer, ow_FlushCommand *object)
 {
-   ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object);
+   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ActiveMQTextMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTextMessage *object)
+apr_status_t ow_marshal2_FlushCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_FlushCommand *object)
 {
-   ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object);   
+   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ActiveMQTextMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTextMessage *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_FlushCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_FlushCommand *object, apr_pool_t *pool)
 {
-   ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool);   
+   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_SubscriptionInfo(ow_DataStructure *object) {
+ow_boolean ow_is_a_BrokerId(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_SUBSCRIPTIONINFO_TYPE:
+
+   case OW_BROKERID_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_SubscriptionInfo *ow_SubscriptionInfo_create(apr_pool_t *pool) 
+ow_BrokerId *ow_BrokerId_create(apr_pool_t *pool) 
 {
-   ow_SubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_SubscriptionInfo));
+   ow_BrokerId *value = apr_pcalloc(pool,sizeof(ow_BrokerId));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_SUBSCRIPTIONINFO_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_BROKERID_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_SubscriptionInfo(ow_bit_buffer *buffer, ow_SubscriptionInfo *object)
+apr_status_t ow_marshal1_BrokerId(ow_bit_buffer *buffer, ow_BrokerId *object)
 {
    ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   ow_marshal1_string(buffer, object->clientId);
-   SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->destination));
-   ow_marshal1_string(buffer, object->selector);
-   ow_marshal1_string(buffer, object->subcriptionName);
+   ow_marshal1_string(buffer, object->value);
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_SubscriptionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *object)
+apr_status_t ow_marshal2_BrokerId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_BrokerId *object)
 {
    ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->clientId));
-   SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->destination));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->selector));
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->subcriptionName));
+   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->value));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_SubscriptionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_BrokerId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_BrokerId *object, apr_pool_t *pool)
 {
    ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->clientId, pool));
-   SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->destination, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->selector, pool));
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->subcriptionName, pool));
+   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->value, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_JournalTransaction(ow_DataStructure *object) {
+ow_boolean ow_is_a_ActiveMQMessage(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_JOURNALTRANSACTION_TYPE:
+
+   case OW_ACTIVEMQOBJECTMESSAGE_TYPE:
+
+   case OW_ACTIVEMQSTREAMMESSAGE_TYPE:
+
+   case OW_ACTIVEMQMESSAGE_TYPE:
+
+   case OW_ACTIVEMQTEXTMESSAGE_TYPE:
+
+   case OW_ACTIVEMQBYTESMESSAGE_TYPE:
+
+   case OW_ACTIVEMQMAPMESSAGE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_JournalTransaction *ow_JournalTransaction_create(apr_pool_t *pool) 
+ow_ActiveMQMessage *ow_ActiveMQMessage_create(apr_pool_t *pool) 
 {
-   ow_JournalTransaction *value = apr_pcalloc(pool,sizeof(ow_JournalTransaction));
+   ow_ActiveMQMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQMessage));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_JOURNALTRANSACTION_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_ACTIVEMQMESSAGE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_JournalTransaction(ow_bit_buffer *buffer, ow_JournalTransaction *object)
+apr_status_t ow_marshal1_ActiveMQMessage(ow_bit_buffer *buffer, ow_ActiveMQMessage *object)
 {
-   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
-   SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->transactionId));
-   
-   ow_bit_buffer_append(buffer, object->wasPrepared);
+   ow_marshal1_Message(buffer, (ow_Message*)object);
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_JournalTransaction(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *object)
+apr_status_t ow_marshal2_ActiveMQMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQMessage *object)
 {
-   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
-   SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId));
-   SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->type));
-   ow_bit_buffer_read(bitbuffer);
+   ow_marshal2_Message(buffer, bitbuffer, (ow_Message*)object);   
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_JournalTransaction(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ActiveMQMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQMessage *object, apr_pool_t *pool)
 {
-   ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool));
-   SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->type));
-   object->wasPrepared = ow_bit_buffer_read(bitbuffer);
+   ow_unmarshal_Message(buffer, bitbuffer, (ow_Message*)object, pool);   
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_ControlCommand(ow_DataStructure *object) {
+ow_boolean ow_is_a_ExceptionResponse(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
-   case OW_CONTROLCOMMAND_TYPE:
+
+   case OW_EXCEPTIONRESPONSE_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_ControlCommand *ow_ControlCommand_create(apr_pool_t *pool) 
+ow_ExceptionResponse *ow_ExceptionResponse_create(apr_pool_t *pool) 
 {
-   ow_ControlCommand *value = apr_pcalloc(pool,sizeof(ow_ControlCommand));
+   ow_ExceptionResponse *value = apr_pcalloc(pool,sizeof(ow_ExceptionResponse));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_CONTROLCOMMAND_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_EXCEPTIONRESPONSE_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_ControlCommand(ow_bit_buffer *buffer, ow_ControlCommand *object)
+apr_status_t ow_marshal1_ExceptionResponse(ow_bit_buffer *buffer, ow_ExceptionResponse *object)
 {
-   ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object);
-   ow_marshal1_string(buffer, object->command);
+   ow_marshal1_Response(buffer, (ow_Response*)object);
+   SUCCESS_CHECK(ow_marshal1_throwable(buffer, object->exception));
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_ControlCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *object)
+apr_status_t ow_marshal2_ExceptionResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ExceptionResponse *object)
 {
-   ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object);   
-   SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->command));
+   ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object);   
+   SUCCESS_CHECK(ow_marshal2_throwable(buffer, bitbuffer, object->exception));
+
    
 	return APR_SUCCESS;
 }
 
-apr_status_t ow_unmarshal_ControlCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *object, apr_pool_t *pool)
+apr_status_t ow_unmarshal_ExceptionResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ExceptionResponse *object, apr_pool_t *pool)
 {
-   ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool);   
-   SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->command, pool));
+   ow_unmarshal_Response(buffer, bitbuffer, (ow_Response*)object, pool);   
+   SUCCESS_CHECK(ow_unmarshal_throwable(buffer, bitbuffer, &object->exception, pool));
+
    
 	return APR_SUCCESS;
 }
-
-ow_boolean ow_is_a_LastPartialCommand(ow_DataStructure *object) {
+ow_boolean ow_is_a_PartialCommand(ow_DataStructure *object) {
    if( object == 0 )
       return 0;
       
    switch(object->structType) {
+
    case OW_LASTPARTIALCOMMAND_TYPE:
+
+   case OW_PARTIALCOMMAND_TYPE:
+
       return 1;
    }
    return 0;
 }
 
 
-ow_LastPartialCommand *ow_LastPartialCommand_create(apr_pool_t *pool) 
+ow_PartialCommand *ow_PartialCommand_create(apr_pool_t *pool) 
 {
-   ow_LastPartialCommand *value = apr_pcalloc(pool,sizeof(ow_LastPartialCommand));
+   ow_PartialCommand *value = apr_pcalloc(pool,sizeof(ow_PartialCommand));
    if( value!=0 ) {
-      ((ow_DataStructure*)value)->structType = OW_LASTPARTIALCOMMAND_TYPE;
+      ((ow_DataStructure*)value)->structType = OW_PARTIALCOMMAND_TYPE;
    }
    return value;
 }
 
 
-apr_status_t ow_marshal1_LastPartialCommand(ow_bit_buffer *buffer, ow_LastPartialCommand *object)
+apr_status_t ow_marshal1_PartialCommand(ow_bit_buffer *buffer, ow_PartialCommand *object)
 {
-   ow_marshal1_PartialCommand(buffer, (ow_PartialCommand*)object);
+   ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object);
+
+   ow_bit_buffer_append(buffer,  object->data!=0 );
+
    
 	return APR_SUCCESS;
 }
-apr_status_t ow_marshal2_LastPartialCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_LastPartialCommand *object)
+apr_status_t ow_marshal2_PartialCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_PartialCommand *object)
 {
-   ow_marshal2_PartialCommand(buffer, bitbuffer, (ow_PartialCommand*)object);   
+   ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object);   
+   SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->commandId));
+
+   SUCCESS_CHECK(ow_marshal2_byte_array(buffer, bitbuffer, object->data));

[... 2672 lines stripped ...]