Return-Path: Delivered-To: apmail-geronimo-activemq-commits-archive@www.apache.org Received: (qmail 69938 invoked from network); 10 Aug 2006 19:53:21 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 10 Aug 2006 19:53:21 -0000 Received: (qmail 54223 invoked by uid 500); 10 Aug 2006 19:53:21 -0000 Delivered-To: apmail-geronimo-activemq-commits-archive@geronimo.apache.org Received: (qmail 54177 invoked by uid 500); 10 Aug 2006 19:53:21 -0000 Mailing-List: contact activemq-commits-help@geronimo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: activemq-dev@geronimo.apache.org Delivered-To: mailing list activemq-commits@geronimo.apache.org Received: (qmail 54146 invoked by uid 99); 10 Aug 2006 19:53:21 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 10 Aug 2006 12:53:21 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 10 Aug 2006 12:53:15 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id 4C8C21A9825; Thu, 10 Aug 2006 12:52:49 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r430504 [5/13] - in /incubator/activemq/trunk: activemq-dotnet/src/main/csharp/ActiveMQ/Commands/ activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ openwire-c/src/libopenwire/ openwire-cpp/src/main/cpp/activemq/command/ openwire-cpp/src... Date: Thu, 10 Aug 2006 19:52:05 -0000 To: activemq-commits@geronimo.apache.org From: jstrachan@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20060810195249.4C8C21A9825@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N Added: incubator/activemq/trunk/openwire-c/src/libopenwire/ow_commands_v2.c URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/openwire-c/src/libopenwire/ow_commands_v2.c?rev=430504&view=auto ============================================================================== --- incubator/activemq/trunk/openwire-c/src/libopenwire/ow_commands_v2.c (added) +++ incubator/activemq/trunk/openwire-c/src/libopenwire/ow_commands_v2.c Thu Aug 10 12:51:56 2006 @@ -0,0 +1,3227 @@ +/** + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/***************************************************************************************** + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + *****************************************************************************************/ + + +#include "ow_commands_v2.h" + +#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; +} + + +ow_LocalTransactionId *ow_LocalTransactionId_create(apr_pool_t *pool) +{ + ow_LocalTransactionId *value = apr_pcalloc(pool,sizeof(ow_LocalTransactionId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_LOCALTRANSACTIONID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_LocalTransactionId(ow_bit_buffer *buffer, ow_LocalTransactionId *object) +{ + 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; +} +apr_status_t ow_marshal2_LocalTransactionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_LocalTransactionId *object) +{ + 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; +} + +apr_status_t ow_unmarshal_LocalTransactionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_LocalTransactionId *object, apr_pool_t *pool) +{ + 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) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_PARTIALCOMMAND_TYPE: + case OW_LASTPARTIALCOMMAND_TYPE: + return 1; + } + return 0; +} + + +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; + } + return value; +} + + +apr_status_t ow_marshal1_PartialCommand(ow_bit_buffer *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_PartialCommand(ow_byte_buffer *buffer, ow_bit_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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_PartialCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_PartialCommand *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) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_INTEGERRESPONSE_TYPE: + return 1; + } + return 0; +} + + +ow_IntegerResponse *ow_IntegerResponse_create(apr_pool_t *pool) +{ + ow_IntegerResponse *value = apr_pcalloc(pool,sizeof(ow_IntegerResponse)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_INTEGERRESPONSE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_IntegerResponse(ow_bit_buffer *buffer, ow_IntegerResponse *object) +{ + ow_marshal1_Response(buffer, (ow_Response*)object); + + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_IntegerResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_IntegerResponse *object) +{ + ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object); + SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->result)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_IntegerResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_IntegerResponse *object, apr_pool_t *pool) +{ + ow_unmarshal_Response(buffer, bitbuffer, (ow_Response*)object, pool); + SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->result)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQQueue(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQQUEUE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQQueue *ow_ActiveMQQueue_create(apr_pool_t *pool) +{ + ow_ActiveMQQueue *value = apr_pcalloc(pool,sizeof(ow_ActiveMQQueue)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQQUEUE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQQueue(ow_bit_buffer *buffer, ow_ActiveMQQueue *object) +{ + ow_marshal1_ActiveMQDestination(buffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQQueue(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQQueue *object) +{ + ow_marshal2_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQQueue(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQQueue *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_TransactionId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_LOCALTRANSACTIONID_TYPE: + case OW_XATRANSACTIONID_TYPE: + return 1; + } + return 0; +} + + +apr_status_t ow_marshal1_TransactionId(ow_bit_buffer *buffer, ow_TransactionId *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + + return APR_SUCCESS; +} +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); + + return APR_SUCCESS; +} + +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); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQObjectMessage(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQOBJECTMESSAGE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQObjectMessage *ow_ActiveMQObjectMessage_create(apr_pool_t *pool) +{ + ow_ActiveMQObjectMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQObjectMessage)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQOBJECTMESSAGE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQObjectMessage(ow_bit_buffer *buffer, ow_ActiveMQObjectMessage *object) +{ + ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQObjectMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object) +{ + ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQObjectMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQObjectMessage *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ConnectionId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONNECTIONID_TYPE: + return 1; + } + return 0; +} + + +ow_ConnectionId *ow_ConnectionId_create(apr_pool_t *pool) +{ + ow_ConnectionId *value = apr_pcalloc(pool,sizeof(ow_ConnectionId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_CONNECTIONID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ConnectionId(ow_bit_buffer *buffer, ow_ConnectionId *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + ow_marshal1_string(buffer, object->value); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ConnectionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *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_ConnectionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionId *object, apr_pool_t *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_ConnectionInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONNECTIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_ConnectionInfo *ow_ConnectionInfo_create(apr_pool_t *pool) +{ + ow_ConnectionInfo *value = apr_pcalloc(pool,sizeof(ow_ConnectionInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_CONNECTIONINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ConnectionInfo(ow_bit_buffer *buffer, ow_ConnectionInfo *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->connectionId)); + 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) +{ + 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->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) +{ + 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->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) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_PRODUCERINFO_TYPE: + return 1; + } + return 0; +} + + +ow_ProducerInfo *ow_ProducerInfo_create(apr_pool_t *pool) +{ + ow_ProducerInfo *value = apr_pcalloc(pool,sizeof(ow_ProducerInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_PRODUCERINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ProducerInfo(ow_bit_buffer *buffer, ow_ProducerInfo *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) +{ + 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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ProducerInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ProducerInfo *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_MessageDispatchNotification(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_MESSAGEDISPATCHNOTIFICATION_TYPE: + return 1; + } + return 0; +} + + +ow_MessageDispatchNotification *ow_MessageDispatchNotification_create(apr_pool_t *pool) +{ + ow_MessageDispatchNotification *value = apr_pcalloc(pool,sizeof(ow_MessageDispatchNotification)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_MESSAGEDISPATCHNOTIFICATION_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_MessageDispatchNotification(ow_bit_buffer *buffer, ow_MessageDispatchNotification *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)); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_MessageDispatchNotification(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageDispatchNotification *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_MessageDispatchNotification(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageDispatchNotification *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_SessionInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_SESSIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_SessionInfo *ow_SessionInfo_create(apr_pool_t *pool) +{ + 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_SessionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *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_SessionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SessionInfo *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_TransactionInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_TRANSACTIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_TransactionInfo *ow_TransactionInfo_create(apr_pool_t *pool) +{ + ow_TransactionInfo *value = apr_pcalloc(pool,sizeof(ow_TransactionInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_TRANSACTIONINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_TransactionInfo(ow_bit_buffer *buffer, ow_TransactionInfo *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_TransactionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *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_TransactionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_TransactionInfo *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)); + SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->type)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQStreamMessage(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQSTREAMMESSAGE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQStreamMessage *ow_ActiveMQStreamMessage_create(apr_pool_t *pool) +{ + ow_ActiveMQStreamMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQStreamMessage)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQSTREAMMESSAGE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQStreamMessage(ow_bit_buffer *buffer, ow_ActiveMQStreamMessage *object) +{ + ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQStreamMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object) +{ + ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQStreamMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQStreamMessage *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_MessageAck(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_MESSAGEACK_TYPE: + return 1; + } + return 0; +} + + +ow_MessageAck *ow_MessageAck_create(apr_pool_t *pool) +{ + ow_MessageAck *value = apr_pcalloc(pool,sizeof(ow_MessageAck)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_MESSAGEACK_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_MessageAck(ow_bit_buffer *buffer, ow_MessageAck *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)); + + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_MessageAck(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageAck *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_MessageAck(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageAck *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ProducerId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_PRODUCERID_TYPE: + return 1; + } + return 0; +} + + +ow_ProducerId *ow_ProducerId_create(apr_pool_t *pool) +{ + ow_ProducerId *value = apr_pcalloc(pool,sizeof(ow_ProducerId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_PRODUCERID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ProducerId(ow_bit_buffer *buffer, ow_ProducerId *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); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ProducerId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ProducerId *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ProducerId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ProducerId *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_MessageId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_MESSAGEID_TYPE: + return 1; + } + return 0; +} + + +ow_MessageId *ow_MessageId_create(apr_pool_t *pool) +{ + ow_MessageId *value = apr_pcalloc(pool,sizeof(ow_MessageId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_MESSAGEID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_MessageId(ow_bit_buffer *buffer, ow_MessageId *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); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_MessageId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessageId *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_MessageId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessageId *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQTempQueue(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQTEMPQUEUE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQTempQueue *ow_ActiveMQTempQueue_create(apr_pool_t *pool) +{ + ow_ActiveMQTempQueue *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTempQueue)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEMPQUEUE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQTempQueue(ow_bit_buffer *buffer, ow_ActiveMQTempQueue *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) +{ + 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) +{ + ow_unmarshal_ActiveMQTempDestination(buffer, bitbuffer, (ow_ActiveMQTempDestination*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_RemoveSubscriptionInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_REMOVESUBSCRIPTIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_RemoveSubscriptionInfo *ow_RemoveSubscriptionInfo_create(apr_pool_t *pool) +{ + ow_RemoveSubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_RemoveSubscriptionInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_REMOVESUBSCRIPTIONINFO_TYPE; + } + return value; +} + + +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); + + return APR_SUCCESS; +} +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)); + + return APR_SUCCESS; +} + +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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_SessionId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_SESSIONID_TYPE: + return 1; + } + return 0; +} + + +ow_SessionId *ow_SessionId_create(apr_pool_t *pool) +{ + ow_SessionId *value = apr_pcalloc(pool,sizeof(ow_SessionId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_SESSIONID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_SessionId(ow_bit_buffer *buffer, ow_SessionId *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + ow_marshal1_string(buffer, object->connectionId); + ow_marshal1_long(buffer, object->value); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_SessionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SessionId *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_SessionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SessionId *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_DataArrayResponse(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_DATAARRAYRESPONSE_TYPE: + return 1; + } + return 0; +} + + +ow_DataArrayResponse *ow_DataArrayResponse_create(apr_pool_t *pool) +{ + ow_DataArrayResponse *value = apr_pcalloc(pool,sizeof(ow_DataArrayResponse)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_DATAARRAYRESPONSE_TYPE; + } + return value; +} + + +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) +{ + ow_marshal2_Response(buffer, bitbuffer, (ow_Response*)object); + SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->data)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_DataArrayResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DataArrayResponse *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_JournalQueueAck(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_JOURNALQUEUEACK_TYPE: + return 1; + } + return 0; +} + + +ow_JournalQueueAck *ow_JournalQueueAck_create(apr_pool_t *pool) +{ + ow_JournalQueueAck *value = apr_pcalloc(pool,sizeof(ow_JournalQueueAck)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_JOURNALQUEUEACK_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_JournalQueueAck(ow_bit_buffer *buffer, ow_JournalQueueAck *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)); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_JournalQueueAck(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalQueueAck *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_JournalQueueAck(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalQueueAck *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_Response(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: + return 1; + } + return 0; +} + + +ow_Response *ow_Response_create(apr_pool_t *pool) +{ + ow_Response *value = apr_pcalloc(pool,sizeof(ow_Response)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_RESPONSE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_Response(ow_bit_buffer *buffer, ow_Response *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; +} + +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_boolean ow_is_a_ConnectionError(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONNECTIONERROR_TYPE: + return 1; + } + return 0; +} + + +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; +} + + +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) +{ + 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)); + + return APR_SUCCESS; +} + +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_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_ConsumerInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONSUMERINFO_TYPE: + return 1; + } + return 0; +} + + +ow_ConsumerInfo *ow_ConsumerInfo_create(apr_pool_t *pool) +{ + ow_ConsumerInfo *value = apr_pcalloc(pool,sizeof(ow_ConsumerInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_CONSUMERINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ConsumerInfo(ow_bit_buffer *buffer, ow_ConsumerInfo *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) +{ + 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) +{ + 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) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_XATRANSACTIONID_TYPE: + return 1; + } + return 0; +} + + +ow_XATransactionId *ow_XATransactionId_create(apr_pool_t *pool) +{ + ow_XATransactionId *value = apr_pcalloc(pool,sizeof(ow_XATransactionId)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_XATRANSACTIONID_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_XATransactionId(ow_bit_buffer *buffer, ow_XATransactionId *object) +{ + ow_marshal1_TransactionId(buffer, (ow_TransactionId*)object); + + + ow_bit_buffer_append(buffer, object->globalTransactionId!=0 ); + + + ow_bit_buffer_append(buffer, object->branchQualifier!=0 ); + + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_XATransactionId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_XATransactionId *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_XATransactionId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_XATransactionId *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_JournalTrace(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_JOURNALTRACE_TYPE: + return 1; + } + return 0; +} + + +ow_JournalTrace *ow_JournalTrace_create(apr_pool_t *pool) +{ + ow_JournalTrace *value = apr_pcalloc(pool,sizeof(ow_JournalTrace)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_JOURNALTRACE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_JournalTrace(ow_bit_buffer *buffer, ow_JournalTrace *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + ow_marshal1_string(buffer, object->message); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_JournalTrace(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalTrace *object) +{ + ow_marshal2_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object); + SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->message)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_JournalTrace(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalTrace *object, apr_pool_t *pool) +{ + ow_unmarshal_DataStructure(buffer, bitbuffer, (ow_DataStructure*)object, pool); + SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->message, pool)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ConsumerId(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONSUMERID_TYPE: + return 1; + } + return 0; +} + + +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; + } + return value; +} + + +apr_status_t ow_marshal1_ConsumerId(ow_bit_buffer *buffer, ow_ConsumerId *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); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ConsumerId(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerId *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ConsumerId(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConsumerId *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQTextMessage(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQTEXTMESSAGE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQTextMessage *ow_ActiveMQTextMessage_create(apr_pool_t *pool) +{ + ow_ActiveMQTextMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTextMessage)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEXTMESSAGE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQTextMessage(ow_bit_buffer *buffer, ow_ActiveMQTextMessage *object) +{ + ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQTextMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTextMessage *object) +{ + ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)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) +{ + ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_SubscriptionInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_SUBSCRIPTIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_SubscriptionInfo *ow_SubscriptionInfo_create(apr_pool_t *pool) +{ + ow_SubscriptionInfo *value = apr_pcalloc(pool,sizeof(ow_SubscriptionInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_SUBSCRIPTIONINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_SubscriptionInfo(ow_bit_buffer *buffer, ow_SubscriptionInfo *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); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_SubscriptionInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *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)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_SubscriptionInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_SubscriptionInfo *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)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_JournalTransaction(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_JOURNALTRANSACTION_TYPE: + return 1; + } + return 0; +} + + +ow_JournalTransaction *ow_JournalTransaction_create(apr_pool_t *pool) +{ + ow_JournalTransaction *value = apr_pcalloc(pool,sizeof(ow_JournalTransaction)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_JOURNALTRANSACTION_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_JournalTransaction(ow_bit_buffer *buffer, ow_JournalTransaction *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); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_JournalTransaction(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *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); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_JournalTransaction(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_JournalTransaction *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); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ControlCommand(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONTROLCOMMAND_TYPE: + return 1; + } + return 0; +} + + +ow_ControlCommand *ow_ControlCommand_create(apr_pool_t *pool) +{ + ow_ControlCommand *value = apr_pcalloc(pool,sizeof(ow_ControlCommand)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_CONTROLCOMMAND_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ControlCommand(ow_bit_buffer *buffer, ow_ControlCommand *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + ow_marshal1_string(buffer, object->command); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ControlCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *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_ControlCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ControlCommand *object, apr_pool_t *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_LastPartialCommand(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_LASTPARTIALCOMMAND_TYPE: + return 1; + } + return 0; +} + + +ow_LastPartialCommand *ow_LastPartialCommand_create(apr_pool_t *pool) +{ + ow_LastPartialCommand *value = apr_pcalloc(pool,sizeof(ow_LastPartialCommand)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_LASTPARTIALCOMMAND_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_LastPartialCommand(ow_bit_buffer *buffer, ow_LastPartialCommand *object) +{ + ow_marshal1_PartialCommand(buffer, (ow_PartialCommand*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_LastPartialCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_LastPartialCommand *object) +{ + ow_marshal2_PartialCommand(buffer, bitbuffer, (ow_PartialCommand*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_LastPartialCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_LastPartialCommand *object, apr_pool_t *pool) +{ + ow_unmarshal_PartialCommand(buffer, bitbuffer, (ow_PartialCommand*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_NetworkBridgeFilter(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_NETWORKBRIDGEFILTER_TYPE: + return 1; + } + return 0; +} + + +ow_NetworkBridgeFilter *ow_NetworkBridgeFilter_create(apr_pool_t *pool) +{ + ow_NetworkBridgeFilter *value = apr_pcalloc(pool,sizeof(ow_NetworkBridgeFilter)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_NETWORKBRIDGEFILTER_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_NetworkBridgeFilter(ow_bit_buffer *buffer, ow_NetworkBridgeFilter *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->networkBrokerId)); + + return APR_SUCCESS; +} +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_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_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_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_MessagePull(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_MESSAGEPULL_TYPE: + return 1; + } + return 0; +} + + +ow_MessagePull *ow_MessagePull_create(apr_pool_t *pool) +{ + ow_MessagePull *value = apr_pcalloc(pool,sizeof(ow_MessagePull)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_MESSAGEPULL_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_MessagePull(ow_bit_buffer *buffer, ow_MessagePull *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->timeout); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_MessagePull(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_MessagePull *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->timeout)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_MessagePull(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_MessagePull *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->timeout, pool)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ActiveMQBytesMessage(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQBYTESMESSAGE_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQBytesMessage *ow_ActiveMQBytesMessage_create(apr_pool_t *pool) +{ + ow_ActiveMQBytesMessage *value = apr_pcalloc(pool,sizeof(ow_ActiveMQBytesMessage)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQBYTESMESSAGE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQBytesMessage(ow_bit_buffer *buffer, ow_ActiveMQBytesMessage *object) +{ + ow_marshal1_ActiveMQMessage(buffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQBytesMessage(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQBytesMessage *object) +{ + ow_marshal2_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQBytesMessage(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQBytesMessage *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQMessage(buffer, bitbuffer, (ow_ActiveMQMessage*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_WireFormatInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_WIREFORMATINFO_TYPE: + return 1; + } + return 0; +} + + +ow_WireFormatInfo *ow_WireFormatInfo_create(apr_pool_t *pool) +{ + ow_WireFormatInfo *value = apr_pcalloc(pool,sizeof(ow_WireFormatInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_WIREFORMATINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_WireFormatInfo(ow_bit_buffer *buffer, ow_WireFormatInfo *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + + + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->marshalledProperties)); + + return APR_SUCCESS; +} +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_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_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_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_ActiveMQTempTopic(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQTEMPTOPIC_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQTempTopic *ow_ActiveMQTempTopic_create(apr_pool_t *pool) +{ + ow_ActiveMQTempTopic *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTempTopic)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTEMPTOPIC_TYPE; + } + return value; +} + + +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_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_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_DiscoveryEvent(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_DISCOVERYEVENT_TYPE: + return 1; + } + return 0; +} + + +ow_DiscoveryEvent *ow_DiscoveryEvent_create(apr_pool_t *pool) +{ + ow_DiscoveryEvent *value = apr_pcalloc(pool,sizeof(ow_DiscoveryEvent)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_DISCOVERYEVENT_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_DiscoveryEvent(ow_bit_buffer *buffer, ow_DiscoveryEvent *object) +{ + 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_DiscoveryEvent(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DiscoveryEvent *object) +{ + 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_DiscoveryEvent(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DiscoveryEvent *object, apr_pool_t *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_ActiveMQTempDestination(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQTEMPQUEUE_TYPE: + case OW_ACTIVEMQTEMPTOPIC_TYPE: + return 1; + } + return 0; +} + + +apr_status_t ow_marshal1_ActiveMQTempDestination(ow_bit_buffer *buffer, ow_ActiveMQTempDestination *object) +{ + ow_marshal1_ActiveMQDestination(buffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQTempDestination(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempDestination *object) +{ + ow_marshal2_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQTempDestination(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTempDestination *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ReplayCommand(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_REPLAYCOMMAND_TYPE: + return 1; + } + return 0; +} + + +ow_ReplayCommand *ow_ReplayCommand_create(apr_pool_t *pool) +{ + ow_ReplayCommand *value = apr_pcalloc(pool,sizeof(ow_ReplayCommand)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_REPLAYCOMMAND_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ReplayCommand(ow_bit_buffer *buffer, ow_ReplayCommand *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + + + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ReplayCommand(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ReplayCommand *object) +{ + 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_ReplayCommand(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ReplayCommand *object, apr_pool_t *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_ActiveMQDestination(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQQUEUE_TYPE: + case OW_ACTIVEMQTEMPQUEUE_TYPE: + case OW_ACTIVEMQTEMPTOPIC_TYPE: + case OW_ACTIVEMQTOPIC_TYPE: + return 1; + } + return 0; +} + + +apr_status_t ow_marshal1_ActiveMQDestination(ow_bit_buffer *buffer, ow_ActiveMQDestination *object) +{ + ow_marshal1_DataStructure(buffer, (ow_DataStructure*)object); + ow_marshal1_string(buffer, object->physicalName); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQDestination(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQDestination *object) +{ + 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_ActiveMQDestination(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQDestination *object, apr_pool_t *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_ActiveMQTopic(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQTOPIC_TYPE: + return 1; + } + return 0; +} + + +ow_ActiveMQTopic *ow_ActiveMQTopic_create(apr_pool_t *pool) +{ + ow_ActiveMQTopic *value = apr_pcalloc(pool,sizeof(ow_ActiveMQTopic)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_ACTIVEMQTOPIC_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ActiveMQTopic(ow_bit_buffer *buffer, ow_ActiveMQTopic *object) +{ + ow_marshal1_ActiveMQDestination(buffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ActiveMQTopic(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTopic *object) +{ + ow_marshal2_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ActiveMQTopic(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ActiveMQTopic *object, apr_pool_t *pool) +{ + ow_unmarshal_ActiveMQDestination(buffer, bitbuffer, (ow_ActiveMQDestination*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_BrokerInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_BROKERINFO_TYPE: + return 1; + } + return 0; +} + + +ow_BrokerInfo *ow_BrokerInfo_create(apr_pool_t *pool) +{ + ow_BrokerInfo *value = apr_pcalloc(pool,sizeof(ow_BrokerInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_BROKERINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_BrokerInfo(ow_bit_buffer *buffer, ow_BrokerInfo *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->brokerId)); + ow_marshal1_string(buffer, object->brokerURL); + SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->peerBrokerInfos)); + ow_marshal1_string(buffer, object->brokerName); + ow_bit_buffer_append(buffer, object->slaveBroker); + ow_bit_buffer_append(buffer, object->masterBroker); + ow_bit_buffer_append(buffer, object->faultTolerantConfiguration); + + return APR_SUCCESS; +} +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_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_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_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_DestinationInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_DESTINATIONINFO_TYPE: + return 1; + } + return 0; +} + + +ow_DestinationInfo *ow_DestinationInfo_create(apr_pool_t *pool) +{ + ow_DestinationInfo *value = apr_pcalloc(pool,sizeof(ow_DestinationInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_DESTINATIONINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_DestinationInfo(ow_bit_buffer *buffer, ow_DestinationInfo *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->destination)); + + ow_marshal1_long(buffer, object->timeout); + SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->brokerPath)); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_DestinationInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DestinationInfo *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->destination)); + SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->operationType)); + SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->timeout)); + SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->brokerPath)); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_DestinationInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DestinationInfo *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->destination, pool)); + SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->operationType)); + SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->timeout, pool)); + SUCCESS_CHECK(ow_unmarshal_DataStructure_array(buffer, bitbuffer, &object->brokerPath, pool)); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_ShutdownInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_SHUTDOWNINFO_TYPE: + return 1; + } + return 0; +} + + +ow_ShutdownInfo *ow_ShutdownInfo_create(apr_pool_t *pool) +{ + ow_ShutdownInfo *value = apr_pcalloc(pool,sizeof(ow_ShutdownInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_SHUTDOWNINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ShutdownInfo(ow_bit_buffer *buffer, ow_ShutdownInfo *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + + return APR_SUCCESS; +} +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); + + return APR_SUCCESS; +} + +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); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_DataResponse(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_DATARESPONSE_TYPE: + return 1; + } + return 0; +} + + +ow_DataResponse *ow_DataResponse_create(apr_pool_t *pool) +{ + ow_DataResponse *value = apr_pcalloc(pool,sizeof(ow_DataResponse)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_DATARESPONSE_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_DataResponse(ow_bit_buffer *buffer, ow_DataResponse *object) +{ + 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_DataResponse(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_DataResponse *object) +{ + 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_DataResponse(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_DataResponse *object, apr_pool_t *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_ConnectionControl(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_CONNECTIONCONTROL_TYPE: + return 1; + } + return 0; +} + + +ow_ConnectionControl *ow_ConnectionControl_create(apr_pool_t *pool) +{ + ow_ConnectionControl *value = apr_pcalloc(pool,sizeof(ow_ConnectionControl)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_CONNECTIONCONTROL_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_ConnectionControl(ow_bit_buffer *buffer, ow_ConnectionControl *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + ow_bit_buffer_append(buffer, object->close); + ow_bit_buffer_append(buffer, object->exit); + ow_bit_buffer_append(buffer, object->faultTolerant); + ow_bit_buffer_append(buffer, object->resume); + ow_bit_buffer_append(buffer, object->suspend); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_ConnectionControl(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionControl *object) +{ + ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object); + ow_bit_buffer_read(bitbuffer); + ow_bit_buffer_read(bitbuffer); + ow_bit_buffer_read(bitbuffer); + ow_bit_buffer_read(bitbuffer); + ow_bit_buffer_read(bitbuffer); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_ConnectionControl(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_ConnectionControl *object, apr_pool_t *pool) +{ + ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool); + object->close = ow_bit_buffer_read(bitbuffer); + object->exit = ow_bit_buffer_read(bitbuffer); + object->faultTolerant = ow_bit_buffer_read(bitbuffer); + object->resume = ow_bit_buffer_read(bitbuffer); + object->suspend = ow_bit_buffer_read(bitbuffer); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_KeepAliveInfo(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_KEEPALIVEINFO_TYPE: + return 1; + } + return 0; +} + + +ow_KeepAliveInfo *ow_KeepAliveInfo_create(apr_pool_t *pool) +{ + ow_KeepAliveInfo *value = apr_pcalloc(pool,sizeof(ow_KeepAliveInfo)); + if( value!=0 ) { + ((ow_DataStructure*)value)->structType = OW_KEEPALIVEINFO_TYPE; + } + return value; +} + + +apr_status_t ow_marshal1_KeepAliveInfo(ow_bit_buffer *buffer, ow_KeepAliveInfo *object) +{ + ow_marshal1_BaseCommand(buffer, (ow_BaseCommand*)object); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_KeepAliveInfo(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_KeepAliveInfo *object) +{ + ow_marshal2_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_KeepAliveInfo(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_KeepAliveInfo *object, apr_pool_t *pool) +{ + ow_unmarshal_BaseCommand(buffer, bitbuffer, (ow_BaseCommand*)object, pool); + + return APR_SUCCESS; +} + +ow_boolean ow_is_a_Message(ow_DataStructure *object) { + if( object == 0 ) + return 0; + + switch(object->structType) { + case OW_ACTIVEMQOBJECTMESSAGE_TYPE: + case OW_ACTIVEMQSTREAMMESSAGE_TYPE: + case OW_ACTIVEMQTEXTMESSAGE_TYPE: + case OW_ACTIVEMQBYTESMESSAGE_TYPE: + case OW_ACTIVEMQMAPMESSAGE_TYPE: + case OW_ACTIVEMQMESSAGE_TYPE: + return 1; + } + return 0; +} + + +apr_status_t ow_marshal1_Message(ow_bit_buffer *buffer, ow_Message *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_cached_object(buffer, (ow_DataStructure*)object->transactionId)); + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->originalDestination)); + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->messageId)); + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->originalTransactionId)); + ow_marshal1_string(buffer, object->groupID); + + ow_marshal1_string(buffer, object->correlationId); + ow_bit_buffer_append(buffer, object->persistent); + ow_marshal1_long(buffer, object->expiration); + + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->replyTo)); + ow_marshal1_long(buffer, object->timestamp); + ow_marshal1_string(buffer, object->type); + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->content)); + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->marshalledProperties)); + SUCCESS_CHECK(ow_marshal1_nested_object(buffer, (ow_DataStructure*)object->dataStructure)); + SUCCESS_CHECK(ow_marshal1_cached_object(buffer, (ow_DataStructure*)object->targetConsumerId)); + ow_bit_buffer_append(buffer, object->compressed); + + SUCCESS_CHECK(ow_marshal1_DataStructure_array(buffer, object->brokerPath)); + ow_marshal1_long(buffer, object->arrival); + ow_marshal1_string(buffer, object->userID); + ow_bit_buffer_append(buffer, object->recievedByDFBridge); + + return APR_SUCCESS; +} +apr_status_t ow_marshal2_Message(ow_byte_buffer *buffer, ow_bit_buffer *bitbuffer, ow_Message *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_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->transactionId)); + SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->originalDestination)); + SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->messageId)); + SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->originalTransactionId)); + SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->groupID)); + SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->groupSequence)); + SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->correlationId)); + ow_bit_buffer_read(bitbuffer); + SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->expiration)); + SUCCESS_CHECK(ow_byte_buffer_append_byte(buffer, object->priority)); + SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->replyTo)); + SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->timestamp)); + SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->type)); + SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->content)); + SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->marshalledProperties)); + SUCCESS_CHECK(ow_marshal2_nested_object(buffer, bitbuffer, (ow_DataStructure*)object->dataStructure)); + SUCCESS_CHECK(ow_marshal2_cached_object(buffer, bitbuffer, (ow_DataStructure*)object->targetConsumerId)); + ow_bit_buffer_read(bitbuffer); + SUCCESS_CHECK(ow_byte_buffer_append_int(buffer, object->redeliveryCounter)); + SUCCESS_CHECK(ow_marshal2_DataStructure_array(buffer, bitbuffer, object->brokerPath)); + SUCCESS_CHECK(ow_marshal2_long(buffer, bitbuffer, object->arrival)); + SUCCESS_CHECK(ow_marshal2_string(buffer, bitbuffer, object->userID)); + ow_bit_buffer_read(bitbuffer); + + return APR_SUCCESS; +} + +apr_status_t ow_unmarshal_Message(ow_byte_array *buffer, ow_bit_buffer *bitbuffer, ow_Message *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_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->transactionId, pool)); + SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->originalDestination, pool)); + SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->messageId, pool)); + SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->originalTransactionId, pool)); + SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->groupID, pool)); + SUCCESS_CHECK(ow_byte_array_read_int(buffer, &object->groupSequence)); + SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->correlationId, pool)); + object->persistent = ow_bit_buffer_read(bitbuffer); + SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->expiration, pool)); + SUCCESS_CHECK(ow_byte_array_read_byte(buffer, &object->priority)); + SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->replyTo, pool)); + SUCCESS_CHECK(ow_unmarshal_long(buffer, bitbuffer, &object->timestamp, pool)); + SUCCESS_CHECK(ow_unmarshal_string(buffer, bitbuffer, &object->type, pool)); + SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->content, pool)); + SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->marshalledProperties, pool)); + SUCCESS_CHECK(ow_unmarshal_nested_object(buffer, bitbuffer, (ow_DataStructure**)&object->dataStructure, pool)); + SUCCESS_CHECK(ow_unmarshal_cached_object(buffer, bitbuffer, (ow_DataStructure**)&object->targetConsumerId, pool)); [... 758 lines stripped ...]