001/** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018package org.apache.activemq.openwire.v1; 019 020import java.io.DataInput; 021import java.io.DataOutput; 022import java.io.IOException; 023 024import org.apache.activemq.command.ConsumerInfo; 025import org.apache.activemq.command.DataStructure; 026import org.apache.activemq.openwire.BooleanStream; 027import org.apache.activemq.openwire.OpenWireFormat; 028 029/** 030 * Marshalling code for Open Wire Format for ConsumerInfoMarshaller 031 * 032 * 033 * NOTE!: This file is auto generated - do not modify! if you need to make a 034 * change, please see the modify the groovy scripts in the under src/gram/script 035 * and then use maven openwire:generate to regenerate this file. 036 * 037 * 038 */ 039public class ConsumerInfoMarshaller extends BaseCommandMarshaller { 040 041 /** 042 * Return the type of Data Structure we marshal 043 * 044 * @return short representation of the type data structure 045 */ 046 public byte getDataStructureType() { 047 return ConsumerInfo.DATA_STRUCTURE_TYPE; 048 } 049 050 /** 051 * @return a new object instance 052 */ 053 public DataStructure createObject() { 054 return new ConsumerInfo(); 055 } 056 057 /** 058 * Un-marshal an object instance from the data input stream 059 * 060 * @param o the object to un-marshal 061 * @param dataIn the data input stream to build the object from 062 * @throws IOException 063 */ 064 public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) 065 throws IOException { 066 super.tightUnmarshal(wireFormat, o, dataIn, bs); 067 068 ConsumerInfo info = (ConsumerInfo)o; 069 info.setConsumerId((org.apache.activemq.command.ConsumerId)tightUnmarsalCachedObject(wireFormat, 070 dataIn, bs)); 071 info.setBrowser(bs.readBoolean()); 072 info 073 .setDestination((org.apache.activemq.command.ActiveMQDestination)tightUnmarsalCachedObject( 074 wireFormat, 075 dataIn, 076 bs)); 077 info.setPrefetchSize(dataIn.readInt()); 078 info.setMaximumPendingMessageLimit(dataIn.readInt()); 079 info.setDispatchAsync(bs.readBoolean()); 080 info.setSelector(tightUnmarshalString(dataIn, bs)); 081 info.setSubscriptionName(tightUnmarshalString(dataIn, bs)); 082 info.setNoLocal(bs.readBoolean()); 083 info.setExclusive(bs.readBoolean()); 084 info.setRetroactive(bs.readBoolean()); 085 info.setPriority(dataIn.readByte()); 086 087 if (bs.readBoolean()) { 088 short size = dataIn.readShort(); 089 org.apache.activemq.command.BrokerId value[] = new org.apache.activemq.command.BrokerId[size]; 090 for (int i = 0; i < size; i++) { 091 value[i] = (org.apache.activemq.command.BrokerId)tightUnmarsalNestedObject(wireFormat, 092 dataIn, bs); 093 } 094 info.setBrokerPath(value); 095 } else { 096 info.setBrokerPath(null); 097 } 098 info 099 .setAdditionalPredicate((org.apache.activemq.filter.BooleanExpression)tightUnmarsalNestedObject( 100 wireFormat, 101 dataIn, 102 bs)); 103 info.setNetworkSubscription(bs.readBoolean()); 104 info.setOptimizedAcknowledge(bs.readBoolean()); 105 info.setNoRangeAcks(bs.readBoolean()); 106 107 } 108 109 /** 110 * Write the booleans that this object uses to a BooleanStream 111 */ 112 public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { 113 114 ConsumerInfo info = (ConsumerInfo)o; 115 116 int rc = super.tightMarshal1(wireFormat, o, bs); 117 rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getConsumerId(), bs); 118 bs.writeBoolean(info.isBrowser()); 119 rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getDestination(), bs); 120 bs.writeBoolean(info.isDispatchAsync()); 121 rc += tightMarshalString1(info.getSelector(), bs); 122 rc += tightMarshalString1(info.getSubscriptionName(), bs); 123 bs.writeBoolean(info.isNoLocal()); 124 bs.writeBoolean(info.isExclusive()); 125 bs.writeBoolean(info.isRetroactive()); 126 rc += tightMarshalObjectArray1(wireFormat, info.getBrokerPath(), bs); 127 rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getAdditionalPredicate(), bs); 128 bs.writeBoolean(info.isNetworkSubscription()); 129 bs.writeBoolean(info.isOptimizedAcknowledge()); 130 bs.writeBoolean(info.isNoRangeAcks()); 131 132 return rc + 9; 133 } 134 135 /** 136 * Write a object instance to data output stream 137 * 138 * @param o the instance to be marshaled 139 * @param dataOut the output stream 140 * @throws IOException thrown if an error occurs 141 */ 142 public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) 143 throws IOException { 144 super.tightMarshal2(wireFormat, o, dataOut, bs); 145 146 ConsumerInfo info = (ConsumerInfo)o; 147 tightMarshalCachedObject2(wireFormat, (DataStructure)info.getConsumerId(), dataOut, bs); 148 bs.readBoolean(); 149 tightMarshalCachedObject2(wireFormat, (DataStructure)info.getDestination(), dataOut, bs); 150 dataOut.writeInt(info.getPrefetchSize()); 151 dataOut.writeInt(info.getMaximumPendingMessageLimit()); 152 bs.readBoolean(); 153 tightMarshalString2(info.getSelector(), dataOut, bs); 154 tightMarshalString2(info.getSubscriptionName(), dataOut, bs); 155 bs.readBoolean(); 156 bs.readBoolean(); 157 bs.readBoolean(); 158 dataOut.writeByte(info.getPriority()); 159 tightMarshalObjectArray2(wireFormat, info.getBrokerPath(), dataOut, bs); 160 tightMarshalNestedObject2(wireFormat, (DataStructure)info.getAdditionalPredicate(), dataOut, bs); 161 bs.readBoolean(); 162 bs.readBoolean(); 163 bs.readBoolean(); 164 165 } 166 167 /** 168 * Un-marshal an object instance from the data input stream 169 * 170 * @param o the object to un-marshal 171 * @param dataIn the data input stream to build the object from 172 * @throws IOException 173 */ 174 public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { 175 super.looseUnmarshal(wireFormat, o, dataIn); 176 177 ConsumerInfo info = (ConsumerInfo)o; 178 info.setConsumerId((org.apache.activemq.command.ConsumerId)looseUnmarsalCachedObject(wireFormat, 179 dataIn)); 180 info.setBrowser(dataIn.readBoolean()); 181 info 182 .setDestination((org.apache.activemq.command.ActiveMQDestination)looseUnmarsalCachedObject( 183 wireFormat, 184 dataIn)); 185 info.setPrefetchSize(dataIn.readInt()); 186 info.setMaximumPendingMessageLimit(dataIn.readInt()); 187 info.setDispatchAsync(dataIn.readBoolean()); 188 info.setSelector(looseUnmarshalString(dataIn)); 189 info.setSubscriptionName(looseUnmarshalString(dataIn)); 190 info.setNoLocal(dataIn.readBoolean()); 191 info.setExclusive(dataIn.readBoolean()); 192 info.setRetroactive(dataIn.readBoolean()); 193 info.setPriority(dataIn.readByte()); 194 195 if (dataIn.readBoolean()) { 196 short size = dataIn.readShort(); 197 org.apache.activemq.command.BrokerId value[] = new org.apache.activemq.command.BrokerId[size]; 198 for (int i = 0; i < size; i++) { 199 value[i] = (org.apache.activemq.command.BrokerId)looseUnmarsalNestedObject(wireFormat, dataIn); 200 } 201 info.setBrokerPath(value); 202 } else { 203 info.setBrokerPath(null); 204 } 205 info 206 .setAdditionalPredicate((org.apache.activemq.filter.BooleanExpression)looseUnmarsalNestedObject( 207 wireFormat, 208 dataIn)); 209 info.setNetworkSubscription(dataIn.readBoolean()); 210 info.setOptimizedAcknowledge(dataIn.readBoolean()); 211 info.setNoRangeAcks(dataIn.readBoolean()); 212 213 } 214 215 /** 216 * Write the booleans that this object uses to a BooleanStream 217 */ 218 public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { 219 220 ConsumerInfo info = (ConsumerInfo)o; 221 222 super.looseMarshal(wireFormat, o, dataOut); 223 looseMarshalCachedObject(wireFormat, (DataStructure)info.getConsumerId(), dataOut); 224 dataOut.writeBoolean(info.isBrowser()); 225 looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); 226 dataOut.writeInt(info.getPrefetchSize()); 227 dataOut.writeInt(info.getMaximumPendingMessageLimit()); 228 dataOut.writeBoolean(info.isDispatchAsync()); 229 looseMarshalString(info.getSelector(), dataOut); 230 looseMarshalString(info.getSubscriptionName(), dataOut); 231 dataOut.writeBoolean(info.isNoLocal()); 232 dataOut.writeBoolean(info.isExclusive()); 233 dataOut.writeBoolean(info.isRetroactive()); 234 dataOut.writeByte(info.getPriority()); 235 looseMarshalObjectArray(wireFormat, info.getBrokerPath(), dataOut); 236 looseMarshalNestedObject(wireFormat, (DataStructure)info.getAdditionalPredicate(), dataOut); 237 dataOut.writeBoolean(info.isNetworkSubscription()); 238 dataOut.writeBoolean(info.isOptimizedAcknowledge()); 239 dataOut.writeBoolean(info.isNoRangeAcks()); 240 241 } 242}