001// 002// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.10-b140310.1920 003// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 004// Any modifications to this file will be lost upon recompilation of the source schema. 005// Generated on: 2018.08.06 at 08:34:13 AM EDT 006// 007 008 009package org.apache.activemq.schema.core; 010 011import java.math.BigInteger; 012import java.util.ArrayList; 013import java.util.HashMap; 014import java.util.List; 015import java.util.Map; 016import javax.xml.bind.JAXBElement; 017import javax.xml.bind.annotation.XmlAccessType; 018import javax.xml.bind.annotation.XmlAccessorType; 019import javax.xml.bind.annotation.XmlAnyAttribute; 020import javax.xml.bind.annotation.XmlAnyElement; 021import javax.xml.bind.annotation.XmlAttribute; 022import javax.xml.bind.annotation.XmlElementRef; 023import javax.xml.bind.annotation.XmlElementRefs; 024import javax.xml.bind.annotation.XmlID; 025import javax.xml.bind.annotation.XmlRootElement; 026import javax.xml.bind.annotation.XmlSchemaType; 027import javax.xml.bind.annotation.XmlType; 028import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; 029import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 030import javax.xml.namespace.QName; 031import org.jvnet.jaxb2_commons.lang.Equals; 032import org.jvnet.jaxb2_commons.lang.EqualsStrategy; 033import org.jvnet.jaxb2_commons.lang.HashCode; 034import org.jvnet.jaxb2_commons.lang.HashCodeStrategy; 035import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy; 036import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; 037import org.jvnet.jaxb2_commons.lang.ToString; 038import org.jvnet.jaxb2_commons.lang.ToStringStrategy; 039import org.jvnet.jaxb2_commons.locator.ObjectLocator; 040import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; 041 042 043/** 044 * <p>Java class for anonymous complex type. 045 * 046 * <p>The following schema fragment specifies the expected content contained within this class. 047 * 048 * <pre> 049 * <complexType> 050 * <complexContent> 051 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 052 * <choice maxOccurs="unbounded" minOccurs="0"> 053 * <choice> 054 * <element name="bridge" minOccurs="0"> 055 * <complexType> 056 * <complexContent> 057 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 058 * <choice minOccurs="0"> 059 * <element ref="{http://activemq.apache.org/schema/core}compositeDemandForwardingBridge"/> 060 * <element ref="{http://activemq.apache.org/schema/core}demandForwardingBridge"/> 061 * <any namespace='##other'/> 062 * </choice> 063 * </restriction> 064 * </complexContent> 065 * </complexType> 066 * </element> 067 * <element name="bridgeFactory" minOccurs="0"> 068 * <complexType> 069 * <complexContent> 070 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 071 * <sequence minOccurs="0"> 072 * <any maxOccurs="unbounded" minOccurs="0"/> 073 * </sequence> 074 * </restriction> 075 * </complexContent> 076 * </complexType> 077 * </element> 078 * <element name="brokerService" minOccurs="0"> 079 * <complexType> 080 * <complexContent> 081 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 082 * <choice minOccurs="0"> 083 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 084 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 085 * <any namespace='##other'/> 086 * </choice> 087 * </restriction> 088 * </complexContent> 089 * </complexType> 090 * </element> 091 * <element name="connectionFilter" minOccurs="0"> 092 * <complexType> 093 * <complexContent> 094 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 095 * <sequence minOccurs="0"> 096 * <any maxOccurs="unbounded" minOccurs="0"/> 097 * </sequence> 098 * </restriction> 099 * </complexContent> 100 * </complexType> 101 * </element> 102 * <element name="durableDestinations" maxOccurs="unbounded" minOccurs="0"> 103 * <complexType> 104 * <complexContent> 105 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 106 * <sequence maxOccurs="unbounded" minOccurs="0"> 107 * <any maxOccurs="unbounded" minOccurs="0"/> 108 * </sequence> 109 * </restriction> 110 * </complexContent> 111 * </complexType> 112 * </element> 113 * <element name="dynamicallyIncludedDestinations" maxOccurs="unbounded" minOccurs="0"> 114 * <complexType> 115 * <complexContent> 116 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 117 * <sequence maxOccurs="unbounded" minOccurs="0"> 118 * <any maxOccurs="unbounded" minOccurs="0"/> 119 * </sequence> 120 * </restriction> 121 * </complexContent> 122 * </complexType> 123 * </element> 124 * <element name="excludedDestinations" maxOccurs="unbounded" minOccurs="0"> 125 * <complexType> 126 * <complexContent> 127 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 128 * <sequence maxOccurs="unbounded" minOccurs="0"> 129 * <any maxOccurs="unbounded" minOccurs="0"/> 130 * </sequence> 131 * </restriction> 132 * </complexContent> 133 * </complexType> 134 * </element> 135 * <element name="localTransport" minOccurs="0"> 136 * <complexType> 137 * <complexContent> 138 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 139 * <sequence minOccurs="0"> 140 * <any maxOccurs="unbounded" minOccurs="0"/> 141 * </sequence> 142 * </restriction> 143 * </complexContent> 144 * </complexType> 145 * </element> 146 * <element name="remoteTransport" minOccurs="0"> 147 * <complexType> 148 * <complexContent> 149 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 150 * <sequence minOccurs="0"> 151 * <any maxOccurs="unbounded" minOccurs="0"/> 152 * </sequence> 153 * </restriction> 154 * </complexContent> 155 * </complexType> 156 * </element> 157 * <element name="staticallyIncludedDestinations" maxOccurs="unbounded" minOccurs="0"> 158 * <complexType> 159 * <complexContent> 160 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 161 * <sequence maxOccurs="unbounded" minOccurs="0"> 162 * <any maxOccurs="unbounded" minOccurs="0"/> 163 * </sequence> 164 * </restriction> 165 * </complexContent> 166 * </complexType> 167 * </element> 168 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 169 * </choice> 170 * </choice> 171 * <attribute name="advisoryAckPercentage" type="{http://www.w3.org/2001/XMLSchema}integer" /> 172 * <attribute name="advisoryForFailedForward" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 173 * <attribute name="advisoryPrefetchSize" type="{http://www.w3.org/2001/XMLSchema}integer" /> 174 * <attribute name="alwaysSyncSend" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 175 * <attribute name="bridge" type="{http://www.w3.org/2001/XMLSchema}string" /> 176 * <attribute name="bridgeFactory" type="{http://www.w3.org/2001/XMLSchema}string" /> 177 * <attribute name="bridgeTempDestinations" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 178 * <attribute name="brokerName" type="{http://www.w3.org/2001/XMLSchema}string" /> 179 * <attribute name="brokerService" type="{http://www.w3.org/2001/XMLSchema}string" /> 180 * <attribute name="brokerURL" type="{http://www.w3.org/2001/XMLSchema}string" /> 181 * <attribute name="checkDuplicateMessagesOnDuplex" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 182 * <attribute name="clientIdToken" type="{http://www.w3.org/2001/XMLSchema}string" /> 183 * <attribute name="conduitNetworkQueueSubscriptions" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 184 * <attribute name="conduitSubscriptions" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 185 * <attribute name="connectionFilter" type="{http://www.w3.org/2001/XMLSchema}string" /> 186 * <attribute name="consumerPriorityBase" type="{http://www.w3.org/2001/XMLSchema}integer" /> 187 * <attribute name="consumerTTL" type="{http://www.w3.org/2001/XMLSchema}integer" /> 188 * <attribute name="decreaseNetworkConsumerPriority" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 189 * <attribute name="destinationFilter" type="{http://www.w3.org/2001/XMLSchema}string" /> 190 * <attribute name="dispatchAsync" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 191 * <attribute name="duplex" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 192 * <attribute name="dynamicOnly" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 193 * <attribute name="gcDestinationViews" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 194 * <attribute name="gcSweepTime" type="{http://www.w3.org/2001/XMLSchema}long" /> 195 * <attribute name="localTransport" type="{http://www.w3.org/2001/XMLSchema}string" /> 196 * <attribute name="localUri" type="{http://www.w3.org/2001/XMLSchema}string" /> 197 * <attribute name="messageTTL" type="{http://www.w3.org/2001/XMLSchema}integer" /> 198 * <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" /> 199 * <attribute name="networkTTL" type="{http://www.w3.org/2001/XMLSchema}integer" /> 200 * <attribute name="objectName" type="{http://www.w3.org/2001/XMLSchema}string" /> 201 * <attribute name="password" type="{http://www.w3.org/2001/XMLSchema}string" /> 202 * <attribute name="prefetchSize" type="{http://www.w3.org/2001/XMLSchema}string" /> 203 * <attribute name="remoteTransport" type="{http://www.w3.org/2001/XMLSchema}string" /> 204 * <attribute name="remoteURI" type="{http://www.w3.org/2001/XMLSchema}string" /> 205 * <attribute name="staticBridge" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 206 * <attribute name="suppressDuplicateQueueSubscriptions" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 207 * <attribute name="suppressDuplicateTopicSubscriptions" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 208 * <attribute name="syncDurableSubs" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 209 * <attribute name="useBrokerNameAsIdSees" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 210 * <attribute name="useCompression" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 211 * <attribute name="useVirtualDestSubs" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 212 * <attribute name="userName" type="{http://www.w3.org/2001/XMLSchema}string" /> 213 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 214 * <anyAttribute processContents='lax' namespace='##other'/> 215 * </restriction> 216 * </complexContent> 217 * </complexType> 218 * </pre> 219 * 220 * 221 */ 222@XmlAccessorType(XmlAccessType.FIELD) 223@XmlType(name = "", propOrder = { 224 "bridgeOrBridgeFactoryOrBrokerService" 225}) 226@XmlRootElement(name = "multicastNetworkConnector") 227public class DtoMulticastNetworkConnector implements Equals, HashCode, ToString 228{ 229 230 @XmlElementRefs({ 231 @XmlElementRef(name = "brokerService", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 232 @XmlElementRef(name = "excludedDestinations", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 233 @XmlElementRef(name = "connectionFilter", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 234 @XmlElementRef(name = "staticallyIncludedDestinations", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 235 @XmlElementRef(name = "bridge", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 236 @XmlElementRef(name = "bridgeFactory", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 237 @XmlElementRef(name = "dynamicallyIncludedDestinations", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 238 @XmlElementRef(name = "remoteTransport", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 239 @XmlElementRef(name = "localTransport", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 240 @XmlElementRef(name = "durableDestinations", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 241 }) 242 @XmlAnyElement(lax = true) 243 protected List<Object> bridgeOrBridgeFactoryOrBrokerService; 244 @XmlAttribute(name = "advisoryAckPercentage") 245 protected BigInteger advisoryAckPercentage; 246 @XmlAttribute(name = "advisoryForFailedForward") 247 protected Boolean advisoryForFailedForward; 248 @XmlAttribute(name = "advisoryPrefetchSize") 249 protected BigInteger advisoryPrefetchSize; 250 @XmlAttribute(name = "alwaysSyncSend") 251 protected Boolean alwaysSyncSend; 252 @XmlAttribute(name = "bridge") 253 protected String bridge; 254 @XmlAttribute(name = "bridgeFactory") 255 protected String bridgeFactory; 256 @XmlAttribute(name = "bridgeTempDestinations") 257 protected Boolean bridgeTempDestinations; 258 @XmlAttribute(name = "brokerName") 259 protected String brokerName; 260 @XmlAttribute(name = "brokerService") 261 protected String brokerService; 262 @XmlAttribute(name = "brokerURL") 263 protected String brokerURL; 264 @XmlAttribute(name = "checkDuplicateMessagesOnDuplex") 265 protected Boolean checkDuplicateMessagesOnDuplex; 266 @XmlAttribute(name = "clientIdToken") 267 protected String clientIdToken; 268 @XmlAttribute(name = "conduitNetworkQueueSubscriptions") 269 protected Boolean conduitNetworkQueueSubscriptions; 270 @XmlAttribute(name = "conduitSubscriptions") 271 protected Boolean conduitSubscriptions; 272 @XmlAttribute(name = "connectionFilter") 273 protected String connectionFilter; 274 @XmlAttribute(name = "consumerPriorityBase") 275 protected BigInteger consumerPriorityBase; 276 @XmlAttribute(name = "consumerTTL") 277 protected BigInteger consumerTTL; 278 @XmlAttribute(name = "decreaseNetworkConsumerPriority") 279 protected Boolean decreaseNetworkConsumerPriority; 280 @XmlAttribute(name = "destinationFilter") 281 protected String destinationFilter; 282 @XmlAttribute(name = "dispatchAsync") 283 protected Boolean dispatchAsync; 284 @XmlAttribute(name = "duplex") 285 protected Boolean duplex; 286 @XmlAttribute(name = "dynamicOnly") 287 protected Boolean dynamicOnly; 288 @XmlAttribute(name = "gcDestinationViews") 289 protected Boolean gcDestinationViews; 290 @XmlAttribute(name = "gcSweepTime") 291 protected Long gcSweepTime; 292 @XmlAttribute(name = "localTransport") 293 protected String localTransport; 294 @XmlAttribute(name = "localUri") 295 protected String localUri; 296 @XmlAttribute(name = "messageTTL") 297 protected BigInteger messageTTL; 298 @XmlAttribute(name = "name") 299 protected String name; 300 @XmlAttribute(name = "networkTTL") 301 protected BigInteger networkTTL; 302 @XmlAttribute(name = "objectName") 303 protected String objectName; 304 @XmlAttribute(name = "password") 305 protected String password; 306 @XmlAttribute(name = "prefetchSize") 307 protected String prefetchSize; 308 @XmlAttribute(name = "remoteTransport") 309 protected String remoteTransport; 310 @XmlAttribute(name = "remoteURI") 311 protected String remoteURI; 312 @XmlAttribute(name = "staticBridge") 313 protected Boolean staticBridge; 314 @XmlAttribute(name = "suppressDuplicateQueueSubscriptions") 315 protected Boolean suppressDuplicateQueueSubscriptions; 316 @XmlAttribute(name = "suppressDuplicateTopicSubscriptions") 317 protected Boolean suppressDuplicateTopicSubscriptions; 318 @XmlAttribute(name = "syncDurableSubs") 319 protected Boolean syncDurableSubs; 320 @XmlAttribute(name = "useBrokerNameAsIdSees") 321 protected Boolean useBrokerNameAsIdSees; 322 @XmlAttribute(name = "useCompression") 323 protected Boolean useCompression; 324 @XmlAttribute(name = "useVirtualDestSubs") 325 protected Boolean useVirtualDestSubs; 326 @XmlAttribute(name = "userName") 327 protected String userName; 328 @XmlAttribute(name = "id") 329 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 330 @XmlID 331 @XmlSchemaType(name = "ID") 332 protected String id; 333 @XmlAnyAttribute 334 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 335 336 /** 337 * Gets the value of the bridgeOrBridgeFactoryOrBrokerService property. 338 * 339 * <p> 340 * This accessor method returns a reference to the live list, 341 * not a snapshot. Therefore any modification you make to the 342 * returned list will be present inside the JAXB object. 343 * This is why there is not a <CODE>set</CODE> method for the bridgeOrBridgeFactoryOrBrokerService property. 344 * 345 * <p> 346 * For example, to add a new item, do as follows: 347 * <pre> 348 * getBridgeOrBridgeFactoryOrBrokerService().add(newItem); 349 * </pre> 350 * 351 * 352 * <p> 353 * Objects of the following type(s) are allowed in the list 354 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.BrokerService }{@code >} 355 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.ExcludedDestinations }{@code >} 356 * {@link Object } 357 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.ConnectionFilter }{@code >} 358 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.StaticallyIncludedDestinations }{@code >} 359 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.Bridge }{@code >} 360 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.BridgeFactory }{@code >} 361 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.DynamicallyIncludedDestinations }{@code >} 362 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.RemoteTransport }{@code >} 363 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.LocalTransport }{@code >} 364 * {@link JAXBElement }{@code <}{@link DtoMulticastNetworkConnector.DurableDestinations }{@code >} 365 * 366 * 367 */ 368 public List<Object> getBridgeOrBridgeFactoryOrBrokerService() { 369 if (bridgeOrBridgeFactoryOrBrokerService == null) { 370 bridgeOrBridgeFactoryOrBrokerService = new ArrayList<Object>(); 371 } 372 return this.bridgeOrBridgeFactoryOrBrokerService; 373 } 374 375 /** 376 * Gets the value of the advisoryAckPercentage property. 377 * 378 * @return 379 * possible object is 380 * {@link BigInteger } 381 * 382 */ 383 public BigInteger getAdvisoryAckPercentage() { 384 return advisoryAckPercentage; 385 } 386 387 /** 388 * Sets the value of the advisoryAckPercentage property. 389 * 390 * @param value 391 * allowed object is 392 * {@link BigInteger } 393 * 394 */ 395 public void setAdvisoryAckPercentage(BigInteger value) { 396 this.advisoryAckPercentage = value; 397 } 398 399 /** 400 * Gets the value of the advisoryForFailedForward property. 401 * 402 * @return 403 * possible object is 404 * {@link Boolean } 405 * 406 */ 407 public Boolean isAdvisoryForFailedForward() { 408 return advisoryForFailedForward; 409 } 410 411 /** 412 * Sets the value of the advisoryForFailedForward property. 413 * 414 * @param value 415 * allowed object is 416 * {@link Boolean } 417 * 418 */ 419 public void setAdvisoryForFailedForward(Boolean value) { 420 this.advisoryForFailedForward = value; 421 } 422 423 /** 424 * Gets the value of the advisoryPrefetchSize property. 425 * 426 * @return 427 * possible object is 428 * {@link BigInteger } 429 * 430 */ 431 public BigInteger getAdvisoryPrefetchSize() { 432 return advisoryPrefetchSize; 433 } 434 435 /** 436 * Sets the value of the advisoryPrefetchSize property. 437 * 438 * @param value 439 * allowed object is 440 * {@link BigInteger } 441 * 442 */ 443 public void setAdvisoryPrefetchSize(BigInteger value) { 444 this.advisoryPrefetchSize = value; 445 } 446 447 /** 448 * Gets the value of the alwaysSyncSend property. 449 * 450 * @return 451 * possible object is 452 * {@link Boolean } 453 * 454 */ 455 public Boolean isAlwaysSyncSend() { 456 return alwaysSyncSend; 457 } 458 459 /** 460 * Sets the value of the alwaysSyncSend property. 461 * 462 * @param value 463 * allowed object is 464 * {@link Boolean } 465 * 466 */ 467 public void setAlwaysSyncSend(Boolean value) { 468 this.alwaysSyncSend = value; 469 } 470 471 /** 472 * Gets the value of the bridge property. 473 * 474 * @return 475 * possible object is 476 * {@link String } 477 * 478 */ 479 public String getBridge() { 480 return bridge; 481 } 482 483 /** 484 * Sets the value of the bridge property. 485 * 486 * @param value 487 * allowed object is 488 * {@link String } 489 * 490 */ 491 public void setBridge(String value) { 492 this.bridge = value; 493 } 494 495 /** 496 * Gets the value of the bridgeFactory property. 497 * 498 * @return 499 * possible object is 500 * {@link String } 501 * 502 */ 503 public String getBridgeFactory() { 504 return bridgeFactory; 505 } 506 507 /** 508 * Sets the value of the bridgeFactory property. 509 * 510 * @param value 511 * allowed object is 512 * {@link String } 513 * 514 */ 515 public void setBridgeFactory(String value) { 516 this.bridgeFactory = value; 517 } 518 519 /** 520 * Gets the value of the bridgeTempDestinations property. 521 * 522 * @return 523 * possible object is 524 * {@link Boolean } 525 * 526 */ 527 public Boolean isBridgeTempDestinations() { 528 return bridgeTempDestinations; 529 } 530 531 /** 532 * Sets the value of the bridgeTempDestinations property. 533 * 534 * @param value 535 * allowed object is 536 * {@link Boolean } 537 * 538 */ 539 public void setBridgeTempDestinations(Boolean value) { 540 this.bridgeTempDestinations = value; 541 } 542 543 /** 544 * Gets the value of the brokerName property. 545 * 546 * @return 547 * possible object is 548 * {@link String } 549 * 550 */ 551 public String getBrokerName() { 552 return brokerName; 553 } 554 555 /** 556 * Sets the value of the brokerName property. 557 * 558 * @param value 559 * allowed object is 560 * {@link String } 561 * 562 */ 563 public void setBrokerName(String value) { 564 this.brokerName = value; 565 } 566 567 /** 568 * Gets the value of the brokerService property. 569 * 570 * @return 571 * possible object is 572 * {@link String } 573 * 574 */ 575 public String getBrokerService() { 576 return brokerService; 577 } 578 579 /** 580 * Sets the value of the brokerService property. 581 * 582 * @param value 583 * allowed object is 584 * {@link String } 585 * 586 */ 587 public void setBrokerService(String value) { 588 this.brokerService = value; 589 } 590 591 /** 592 * Gets the value of the brokerURL property. 593 * 594 * @return 595 * possible object is 596 * {@link String } 597 * 598 */ 599 public String getBrokerURL() { 600 return brokerURL; 601 } 602 603 /** 604 * Sets the value of the brokerURL property. 605 * 606 * @param value 607 * allowed object is 608 * {@link String } 609 * 610 */ 611 public void setBrokerURL(String value) { 612 this.brokerURL = value; 613 } 614 615 /** 616 * Gets the value of the checkDuplicateMessagesOnDuplex property. 617 * 618 * @return 619 * possible object is 620 * {@link Boolean } 621 * 622 */ 623 public Boolean isCheckDuplicateMessagesOnDuplex() { 624 return checkDuplicateMessagesOnDuplex; 625 } 626 627 /** 628 * Sets the value of the checkDuplicateMessagesOnDuplex property. 629 * 630 * @param value 631 * allowed object is 632 * {@link Boolean } 633 * 634 */ 635 public void setCheckDuplicateMessagesOnDuplex(Boolean value) { 636 this.checkDuplicateMessagesOnDuplex = value; 637 } 638 639 /** 640 * Gets the value of the clientIdToken property. 641 * 642 * @return 643 * possible object is 644 * {@link String } 645 * 646 */ 647 public String getClientIdToken() { 648 return clientIdToken; 649 } 650 651 /** 652 * Sets the value of the clientIdToken property. 653 * 654 * @param value 655 * allowed object is 656 * {@link String } 657 * 658 */ 659 public void setClientIdToken(String value) { 660 this.clientIdToken = value; 661 } 662 663 /** 664 * Gets the value of the conduitNetworkQueueSubscriptions property. 665 * 666 * @return 667 * possible object is 668 * {@link Boolean } 669 * 670 */ 671 public Boolean isConduitNetworkQueueSubscriptions() { 672 return conduitNetworkQueueSubscriptions; 673 } 674 675 /** 676 * Sets the value of the conduitNetworkQueueSubscriptions property. 677 * 678 * @param value 679 * allowed object is 680 * {@link Boolean } 681 * 682 */ 683 public void setConduitNetworkQueueSubscriptions(Boolean value) { 684 this.conduitNetworkQueueSubscriptions = value; 685 } 686 687 /** 688 * Gets the value of the conduitSubscriptions property. 689 * 690 * @return 691 * possible object is 692 * {@link Boolean } 693 * 694 */ 695 public Boolean isConduitSubscriptions() { 696 return conduitSubscriptions; 697 } 698 699 /** 700 * Sets the value of the conduitSubscriptions property. 701 * 702 * @param value 703 * allowed object is 704 * {@link Boolean } 705 * 706 */ 707 public void setConduitSubscriptions(Boolean value) { 708 this.conduitSubscriptions = value; 709 } 710 711 /** 712 * Gets the value of the connectionFilter property. 713 * 714 * @return 715 * possible object is 716 * {@link String } 717 * 718 */ 719 public String getConnectionFilter() { 720 return connectionFilter; 721 } 722 723 /** 724 * Sets the value of the connectionFilter property. 725 * 726 * @param value 727 * allowed object is 728 * {@link String } 729 * 730 */ 731 public void setConnectionFilter(String value) { 732 this.connectionFilter = value; 733 } 734 735 /** 736 * Gets the value of the consumerPriorityBase property. 737 * 738 * @return 739 * possible object is 740 * {@link BigInteger } 741 * 742 */ 743 public BigInteger getConsumerPriorityBase() { 744 return consumerPriorityBase; 745 } 746 747 /** 748 * Sets the value of the consumerPriorityBase property. 749 * 750 * @param value 751 * allowed object is 752 * {@link BigInteger } 753 * 754 */ 755 public void setConsumerPriorityBase(BigInteger value) { 756 this.consumerPriorityBase = value; 757 } 758 759 /** 760 * Gets the value of the consumerTTL property. 761 * 762 * @return 763 * possible object is 764 * {@link BigInteger } 765 * 766 */ 767 public BigInteger getConsumerTTL() { 768 return consumerTTL; 769 } 770 771 /** 772 * Sets the value of the consumerTTL property. 773 * 774 * @param value 775 * allowed object is 776 * {@link BigInteger } 777 * 778 */ 779 public void setConsumerTTL(BigInteger value) { 780 this.consumerTTL = value; 781 } 782 783 /** 784 * Gets the value of the decreaseNetworkConsumerPriority property. 785 * 786 * @return 787 * possible object is 788 * {@link Boolean } 789 * 790 */ 791 public Boolean isDecreaseNetworkConsumerPriority() { 792 return decreaseNetworkConsumerPriority; 793 } 794 795 /** 796 * Sets the value of the decreaseNetworkConsumerPriority property. 797 * 798 * @param value 799 * allowed object is 800 * {@link Boolean } 801 * 802 */ 803 public void setDecreaseNetworkConsumerPriority(Boolean value) { 804 this.decreaseNetworkConsumerPriority = value; 805 } 806 807 /** 808 * Gets the value of the destinationFilter property. 809 * 810 * @return 811 * possible object is 812 * {@link String } 813 * 814 */ 815 public String getDestinationFilter() { 816 return destinationFilter; 817 } 818 819 /** 820 * Sets the value of the destinationFilter property. 821 * 822 * @param value 823 * allowed object is 824 * {@link String } 825 * 826 */ 827 public void setDestinationFilter(String value) { 828 this.destinationFilter = value; 829 } 830 831 /** 832 * Gets the value of the dispatchAsync property. 833 * 834 * @return 835 * possible object is 836 * {@link Boolean } 837 * 838 */ 839 public Boolean isDispatchAsync() { 840 return dispatchAsync; 841 } 842 843 /** 844 * Sets the value of the dispatchAsync property. 845 * 846 * @param value 847 * allowed object is 848 * {@link Boolean } 849 * 850 */ 851 public void setDispatchAsync(Boolean value) { 852 this.dispatchAsync = value; 853 } 854 855 /** 856 * Gets the value of the duplex property. 857 * 858 * @return 859 * possible object is 860 * {@link Boolean } 861 * 862 */ 863 public Boolean isDuplex() { 864 return duplex; 865 } 866 867 /** 868 * Sets the value of the duplex property. 869 * 870 * @param value 871 * allowed object is 872 * {@link Boolean } 873 * 874 */ 875 public void setDuplex(Boolean value) { 876 this.duplex = value; 877 } 878 879 /** 880 * Gets the value of the dynamicOnly property. 881 * 882 * @return 883 * possible object is 884 * {@link Boolean } 885 * 886 */ 887 public Boolean isDynamicOnly() { 888 return dynamicOnly; 889 } 890 891 /** 892 * Sets the value of the dynamicOnly property. 893 * 894 * @param value 895 * allowed object is 896 * {@link Boolean } 897 * 898 */ 899 public void setDynamicOnly(Boolean value) { 900 this.dynamicOnly = value; 901 } 902 903 /** 904 * Gets the value of the gcDestinationViews property. 905 * 906 * @return 907 * possible object is 908 * {@link Boolean } 909 * 910 */ 911 public Boolean isGcDestinationViews() { 912 return gcDestinationViews; 913 } 914 915 /** 916 * Sets the value of the gcDestinationViews property. 917 * 918 * @param value 919 * allowed object is 920 * {@link Boolean } 921 * 922 */ 923 public void setGcDestinationViews(Boolean value) { 924 this.gcDestinationViews = value; 925 } 926 927 /** 928 * Gets the value of the gcSweepTime property. 929 * 930 * @return 931 * possible object is 932 * {@link Long } 933 * 934 */ 935 public Long getGcSweepTime() { 936 return gcSweepTime; 937 } 938 939 /** 940 * Sets the value of the gcSweepTime property. 941 * 942 * @param value 943 * allowed object is 944 * {@link Long } 945 * 946 */ 947 public void setGcSweepTime(Long value) { 948 this.gcSweepTime = value; 949 } 950 951 /** 952 * Gets the value of the localTransport property. 953 * 954 * @return 955 * possible object is 956 * {@link String } 957 * 958 */ 959 public String getLocalTransport() { 960 return localTransport; 961 } 962 963 /** 964 * Sets the value of the localTransport property. 965 * 966 * @param value 967 * allowed object is 968 * {@link String } 969 * 970 */ 971 public void setLocalTransport(String value) { 972 this.localTransport = value; 973 } 974 975 /** 976 * Gets the value of the localUri property. 977 * 978 * @return 979 * possible object is 980 * {@link String } 981 * 982 */ 983 public String getLocalUri() { 984 return localUri; 985 } 986 987 /** 988 * Sets the value of the localUri property. 989 * 990 * @param value 991 * allowed object is 992 * {@link String } 993 * 994 */ 995 public void setLocalUri(String value) { 996 this.localUri = value; 997 } 998 999 /** 1000 * Gets the value of the messageTTL property. 1001 * 1002 * @return 1003 * possible object is 1004 * {@link BigInteger } 1005 * 1006 */ 1007 public BigInteger getMessageTTL() { 1008 return messageTTL; 1009 } 1010 1011 /** 1012 * Sets the value of the messageTTL property. 1013 * 1014 * @param value 1015 * allowed object is 1016 * {@link BigInteger } 1017 * 1018 */ 1019 public void setMessageTTL(BigInteger value) { 1020 this.messageTTL = value; 1021 } 1022 1023 /** 1024 * Gets the value of the name property. 1025 * 1026 * @return 1027 * possible object is 1028 * {@link String } 1029 * 1030 */ 1031 public String getName() { 1032 return name; 1033 } 1034 1035 /** 1036 * Sets the value of the name property. 1037 * 1038 * @param value 1039 * allowed object is 1040 * {@link String } 1041 * 1042 */ 1043 public void setName(String value) { 1044 this.name = value; 1045 } 1046 1047 /** 1048 * Gets the value of the networkTTL property. 1049 * 1050 * @return 1051 * possible object is 1052 * {@link BigInteger } 1053 * 1054 */ 1055 public BigInteger getNetworkTTL() { 1056 return networkTTL; 1057 } 1058 1059 /** 1060 * Sets the value of the networkTTL property. 1061 * 1062 * @param value 1063 * allowed object is 1064 * {@link BigInteger } 1065 * 1066 */ 1067 public void setNetworkTTL(BigInteger value) { 1068 this.networkTTL = value; 1069 } 1070 1071 /** 1072 * Gets the value of the objectName property. 1073 * 1074 * @return 1075 * possible object is 1076 * {@link String } 1077 * 1078 */ 1079 public String getObjectName() { 1080 return objectName; 1081 } 1082 1083 /** 1084 * Sets the value of the objectName property. 1085 * 1086 * @param value 1087 * allowed object is 1088 * {@link String } 1089 * 1090 */ 1091 public void setObjectName(String value) { 1092 this.objectName = value; 1093 } 1094 1095 /** 1096 * Gets the value of the password property. 1097 * 1098 * @return 1099 * possible object is 1100 * {@link String } 1101 * 1102 */ 1103 public String getPassword() { 1104 return password; 1105 } 1106 1107 /** 1108 * Sets the value of the password property. 1109 * 1110 * @param value 1111 * allowed object is 1112 * {@link String } 1113 * 1114 */ 1115 public void setPassword(String value) { 1116 this.password = value; 1117 } 1118 1119 /** 1120 * Gets the value of the prefetchSize property. 1121 * 1122 * @return 1123 * possible object is 1124 * {@link String } 1125 * 1126 */ 1127 public String getPrefetchSize() { 1128 return prefetchSize; 1129 } 1130 1131 /** 1132 * Sets the value of the prefetchSize property. 1133 * 1134 * @param value 1135 * allowed object is 1136 * {@link String } 1137 * 1138 */ 1139 public void setPrefetchSize(String value) { 1140 this.prefetchSize = value; 1141 } 1142 1143 /** 1144 * Gets the value of the remoteTransport property. 1145 * 1146 * @return 1147 * possible object is 1148 * {@link String } 1149 * 1150 */ 1151 public String getRemoteTransport() { 1152 return remoteTransport; 1153 } 1154 1155 /** 1156 * Sets the value of the remoteTransport property. 1157 * 1158 * @param value 1159 * allowed object is 1160 * {@link String } 1161 * 1162 */ 1163 public void setRemoteTransport(String value) { 1164 this.remoteTransport = value; 1165 } 1166 1167 /** 1168 * Gets the value of the remoteURI property. 1169 * 1170 * @return 1171 * possible object is 1172 * {@link String } 1173 * 1174 */ 1175 public String getRemoteURI() { 1176 return remoteURI; 1177 } 1178 1179 /** 1180 * Sets the value of the remoteURI property. 1181 * 1182 * @param value 1183 * allowed object is 1184 * {@link String } 1185 * 1186 */ 1187 public void setRemoteURI(String value) { 1188 this.remoteURI = value; 1189 } 1190 1191 /** 1192 * Gets the value of the staticBridge property. 1193 * 1194 * @return 1195 * possible object is 1196 * {@link Boolean } 1197 * 1198 */ 1199 public Boolean isStaticBridge() { 1200 return staticBridge; 1201 } 1202 1203 /** 1204 * Sets the value of the staticBridge property. 1205 * 1206 * @param value 1207 * allowed object is 1208 * {@link Boolean } 1209 * 1210 */ 1211 public void setStaticBridge(Boolean value) { 1212 this.staticBridge = value; 1213 } 1214 1215 /** 1216 * Gets the value of the suppressDuplicateQueueSubscriptions property. 1217 * 1218 * @return 1219 * possible object is 1220 * {@link Boolean } 1221 * 1222 */ 1223 public Boolean isSuppressDuplicateQueueSubscriptions() { 1224 return suppressDuplicateQueueSubscriptions; 1225 } 1226 1227 /** 1228 * Sets the value of the suppressDuplicateQueueSubscriptions property. 1229 * 1230 * @param value 1231 * allowed object is 1232 * {@link Boolean } 1233 * 1234 */ 1235 public void setSuppressDuplicateQueueSubscriptions(Boolean value) { 1236 this.suppressDuplicateQueueSubscriptions = value; 1237 } 1238 1239 /** 1240 * Gets the value of the suppressDuplicateTopicSubscriptions property. 1241 * 1242 * @return 1243 * possible object is 1244 * {@link Boolean } 1245 * 1246 */ 1247 public Boolean isSuppressDuplicateTopicSubscriptions() { 1248 return suppressDuplicateTopicSubscriptions; 1249 } 1250 1251 /** 1252 * Sets the value of the suppressDuplicateTopicSubscriptions property. 1253 * 1254 * @param value 1255 * allowed object is 1256 * {@link Boolean } 1257 * 1258 */ 1259 public void setSuppressDuplicateTopicSubscriptions(Boolean value) { 1260 this.suppressDuplicateTopicSubscriptions = value; 1261 } 1262 1263 /** 1264 * Gets the value of the syncDurableSubs property. 1265 * 1266 * @return 1267 * possible object is 1268 * {@link Boolean } 1269 * 1270 */ 1271 public Boolean isSyncDurableSubs() { 1272 return syncDurableSubs; 1273 } 1274 1275 /** 1276 * Sets the value of the syncDurableSubs property. 1277 * 1278 * @param value 1279 * allowed object is 1280 * {@link Boolean } 1281 * 1282 */ 1283 public void setSyncDurableSubs(Boolean value) { 1284 this.syncDurableSubs = value; 1285 } 1286 1287 /** 1288 * Gets the value of the useBrokerNameAsIdSees property. 1289 * 1290 * @return 1291 * possible object is 1292 * {@link Boolean } 1293 * 1294 */ 1295 public Boolean isUseBrokerNameAsIdSees() { 1296 return useBrokerNameAsIdSees; 1297 } 1298 1299 /** 1300 * Sets the value of the useBrokerNameAsIdSees property. 1301 * 1302 * @param value 1303 * allowed object is 1304 * {@link Boolean } 1305 * 1306 */ 1307 public void setUseBrokerNameAsIdSees(Boolean value) { 1308 this.useBrokerNameAsIdSees = value; 1309 } 1310 1311 /** 1312 * Gets the value of the useCompression property. 1313 * 1314 * @return 1315 * possible object is 1316 * {@link Boolean } 1317 * 1318 */ 1319 public Boolean isUseCompression() { 1320 return useCompression; 1321 } 1322 1323 /** 1324 * Sets the value of the useCompression property. 1325 * 1326 * @param value 1327 * allowed object is 1328 * {@link Boolean } 1329 * 1330 */ 1331 public void setUseCompression(Boolean value) { 1332 this.useCompression = value; 1333 } 1334 1335 /** 1336 * Gets the value of the useVirtualDestSubs property. 1337 * 1338 * @return 1339 * possible object is 1340 * {@link Boolean } 1341 * 1342 */ 1343 public Boolean isUseVirtualDestSubs() { 1344 return useVirtualDestSubs; 1345 } 1346 1347 /** 1348 * Sets the value of the useVirtualDestSubs property. 1349 * 1350 * @param value 1351 * allowed object is 1352 * {@link Boolean } 1353 * 1354 */ 1355 public void setUseVirtualDestSubs(Boolean value) { 1356 this.useVirtualDestSubs = value; 1357 } 1358 1359 /** 1360 * Gets the value of the userName property. 1361 * 1362 * @return 1363 * possible object is 1364 * {@link String } 1365 * 1366 */ 1367 public String getUserName() { 1368 return userName; 1369 } 1370 1371 /** 1372 * Sets the value of the userName property. 1373 * 1374 * @param value 1375 * allowed object is 1376 * {@link String } 1377 * 1378 */ 1379 public void setUserName(String value) { 1380 this.userName = value; 1381 } 1382 1383 /** 1384 * Gets the value of the id property. 1385 * 1386 * @return 1387 * possible object is 1388 * {@link String } 1389 * 1390 */ 1391 public String getId() { 1392 return id; 1393 } 1394 1395 /** 1396 * Sets the value of the id property. 1397 * 1398 * @param value 1399 * allowed object is 1400 * {@link String } 1401 * 1402 */ 1403 public void setId(String value) { 1404 this.id = value; 1405 } 1406 1407 /** 1408 * Gets a map that contains attributes that aren't bound to any typed property on this class. 1409 * 1410 * <p> 1411 * the map is keyed by the name of the attribute and 1412 * the value is the string value of the attribute. 1413 * 1414 * the map returned by this method is live, and you can add new attribute 1415 * by updating the map directly. Because of this design, there's no setter. 1416 * 1417 * 1418 * @return 1419 * always non-null 1420 */ 1421 public Map<QName, String> getOtherAttributes() { 1422 return otherAttributes; 1423 } 1424 1425 public String toString() { 1426 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1427 final StringBuilder buffer = new StringBuilder(); 1428 append(null, buffer, strategy); 1429 return buffer.toString(); 1430 } 1431 1432 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1433 strategy.appendStart(locator, this, buffer); 1434 appendFields(locator, buffer, strategy); 1435 strategy.appendEnd(locator, this, buffer); 1436 return buffer; 1437 } 1438 1439 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1440 { 1441 List<Object> theBridgeOrBridgeFactoryOrBrokerService; 1442 theBridgeOrBridgeFactoryOrBrokerService = (((this.bridgeOrBridgeFactoryOrBrokerService!= null)&&(!this.bridgeOrBridgeFactoryOrBrokerService.isEmpty()))?this.getBridgeOrBridgeFactoryOrBrokerService():null); 1443 strategy.appendField(locator, this, "bridgeOrBridgeFactoryOrBrokerService", buffer, theBridgeOrBridgeFactoryOrBrokerService); 1444 } 1445 { 1446 BigInteger theAdvisoryAckPercentage; 1447 theAdvisoryAckPercentage = this.getAdvisoryAckPercentage(); 1448 strategy.appendField(locator, this, "advisoryAckPercentage", buffer, theAdvisoryAckPercentage); 1449 } 1450 { 1451 Boolean theAdvisoryForFailedForward; 1452 theAdvisoryForFailedForward = this.isAdvisoryForFailedForward(); 1453 strategy.appendField(locator, this, "advisoryForFailedForward", buffer, theAdvisoryForFailedForward); 1454 } 1455 { 1456 BigInteger theAdvisoryPrefetchSize; 1457 theAdvisoryPrefetchSize = this.getAdvisoryPrefetchSize(); 1458 strategy.appendField(locator, this, "advisoryPrefetchSize", buffer, theAdvisoryPrefetchSize); 1459 } 1460 { 1461 Boolean theAlwaysSyncSend; 1462 theAlwaysSyncSend = this.isAlwaysSyncSend(); 1463 strategy.appendField(locator, this, "alwaysSyncSend", buffer, theAlwaysSyncSend); 1464 } 1465 { 1466 String theBridge; 1467 theBridge = this.getBridge(); 1468 strategy.appendField(locator, this, "bridge", buffer, theBridge); 1469 } 1470 { 1471 String theBridgeFactory; 1472 theBridgeFactory = this.getBridgeFactory(); 1473 strategy.appendField(locator, this, "bridgeFactory", buffer, theBridgeFactory); 1474 } 1475 { 1476 Boolean theBridgeTempDestinations; 1477 theBridgeTempDestinations = this.isBridgeTempDestinations(); 1478 strategy.appendField(locator, this, "bridgeTempDestinations", buffer, theBridgeTempDestinations); 1479 } 1480 { 1481 String theBrokerName; 1482 theBrokerName = this.getBrokerName(); 1483 strategy.appendField(locator, this, "brokerName", buffer, theBrokerName); 1484 } 1485 { 1486 String theBrokerService; 1487 theBrokerService = this.getBrokerService(); 1488 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 1489 } 1490 { 1491 String theBrokerURL; 1492 theBrokerURL = this.getBrokerURL(); 1493 strategy.appendField(locator, this, "brokerURL", buffer, theBrokerURL); 1494 } 1495 { 1496 Boolean theCheckDuplicateMessagesOnDuplex; 1497 theCheckDuplicateMessagesOnDuplex = this.isCheckDuplicateMessagesOnDuplex(); 1498 strategy.appendField(locator, this, "checkDuplicateMessagesOnDuplex", buffer, theCheckDuplicateMessagesOnDuplex); 1499 } 1500 { 1501 String theClientIdToken; 1502 theClientIdToken = this.getClientIdToken(); 1503 strategy.appendField(locator, this, "clientIdToken", buffer, theClientIdToken); 1504 } 1505 { 1506 Boolean theConduitNetworkQueueSubscriptions; 1507 theConduitNetworkQueueSubscriptions = this.isConduitNetworkQueueSubscriptions(); 1508 strategy.appendField(locator, this, "conduitNetworkQueueSubscriptions", buffer, theConduitNetworkQueueSubscriptions); 1509 } 1510 { 1511 Boolean theConduitSubscriptions; 1512 theConduitSubscriptions = this.isConduitSubscriptions(); 1513 strategy.appendField(locator, this, "conduitSubscriptions", buffer, theConduitSubscriptions); 1514 } 1515 { 1516 String theConnectionFilter; 1517 theConnectionFilter = this.getConnectionFilter(); 1518 strategy.appendField(locator, this, "connectionFilter", buffer, theConnectionFilter); 1519 } 1520 { 1521 BigInteger theConsumerPriorityBase; 1522 theConsumerPriorityBase = this.getConsumerPriorityBase(); 1523 strategy.appendField(locator, this, "consumerPriorityBase", buffer, theConsumerPriorityBase); 1524 } 1525 { 1526 BigInteger theConsumerTTL; 1527 theConsumerTTL = this.getConsumerTTL(); 1528 strategy.appendField(locator, this, "consumerTTL", buffer, theConsumerTTL); 1529 } 1530 { 1531 Boolean theDecreaseNetworkConsumerPriority; 1532 theDecreaseNetworkConsumerPriority = this.isDecreaseNetworkConsumerPriority(); 1533 strategy.appendField(locator, this, "decreaseNetworkConsumerPriority", buffer, theDecreaseNetworkConsumerPriority); 1534 } 1535 { 1536 String theDestinationFilter; 1537 theDestinationFilter = this.getDestinationFilter(); 1538 strategy.appendField(locator, this, "destinationFilter", buffer, theDestinationFilter); 1539 } 1540 { 1541 Boolean theDispatchAsync; 1542 theDispatchAsync = this.isDispatchAsync(); 1543 strategy.appendField(locator, this, "dispatchAsync", buffer, theDispatchAsync); 1544 } 1545 { 1546 Boolean theDuplex; 1547 theDuplex = this.isDuplex(); 1548 strategy.appendField(locator, this, "duplex", buffer, theDuplex); 1549 } 1550 { 1551 Boolean theDynamicOnly; 1552 theDynamicOnly = this.isDynamicOnly(); 1553 strategy.appendField(locator, this, "dynamicOnly", buffer, theDynamicOnly); 1554 } 1555 { 1556 Boolean theGcDestinationViews; 1557 theGcDestinationViews = this.isGcDestinationViews(); 1558 strategy.appendField(locator, this, "gcDestinationViews", buffer, theGcDestinationViews); 1559 } 1560 { 1561 Long theGcSweepTime; 1562 theGcSweepTime = this.getGcSweepTime(); 1563 strategy.appendField(locator, this, "gcSweepTime", buffer, theGcSweepTime); 1564 } 1565 { 1566 String theLocalTransport; 1567 theLocalTransport = this.getLocalTransport(); 1568 strategy.appendField(locator, this, "localTransport", buffer, theLocalTransport); 1569 } 1570 { 1571 String theLocalUri; 1572 theLocalUri = this.getLocalUri(); 1573 strategy.appendField(locator, this, "localUri", buffer, theLocalUri); 1574 } 1575 { 1576 BigInteger theMessageTTL; 1577 theMessageTTL = this.getMessageTTL(); 1578 strategy.appendField(locator, this, "messageTTL", buffer, theMessageTTL); 1579 } 1580 { 1581 String theName; 1582 theName = this.getName(); 1583 strategy.appendField(locator, this, "name", buffer, theName); 1584 } 1585 { 1586 BigInteger theNetworkTTL; 1587 theNetworkTTL = this.getNetworkTTL(); 1588 strategy.appendField(locator, this, "networkTTL", buffer, theNetworkTTL); 1589 } 1590 { 1591 String theObjectName; 1592 theObjectName = this.getObjectName(); 1593 strategy.appendField(locator, this, "objectName", buffer, theObjectName); 1594 } 1595 { 1596 String thePassword; 1597 thePassword = this.getPassword(); 1598 strategy.appendField(locator, this, "password", buffer, thePassword); 1599 } 1600 { 1601 String thePrefetchSize; 1602 thePrefetchSize = this.getPrefetchSize(); 1603 strategy.appendField(locator, this, "prefetchSize", buffer, thePrefetchSize); 1604 } 1605 { 1606 String theRemoteTransport; 1607 theRemoteTransport = this.getRemoteTransport(); 1608 strategy.appendField(locator, this, "remoteTransport", buffer, theRemoteTransport); 1609 } 1610 { 1611 String theRemoteURI; 1612 theRemoteURI = this.getRemoteURI(); 1613 strategy.appendField(locator, this, "remoteURI", buffer, theRemoteURI); 1614 } 1615 { 1616 Boolean theStaticBridge; 1617 theStaticBridge = this.isStaticBridge(); 1618 strategy.appendField(locator, this, "staticBridge", buffer, theStaticBridge); 1619 } 1620 { 1621 Boolean theSuppressDuplicateQueueSubscriptions; 1622 theSuppressDuplicateQueueSubscriptions = this.isSuppressDuplicateQueueSubscriptions(); 1623 strategy.appendField(locator, this, "suppressDuplicateQueueSubscriptions", buffer, theSuppressDuplicateQueueSubscriptions); 1624 } 1625 { 1626 Boolean theSuppressDuplicateTopicSubscriptions; 1627 theSuppressDuplicateTopicSubscriptions = this.isSuppressDuplicateTopicSubscriptions(); 1628 strategy.appendField(locator, this, "suppressDuplicateTopicSubscriptions", buffer, theSuppressDuplicateTopicSubscriptions); 1629 } 1630 { 1631 Boolean theSyncDurableSubs; 1632 theSyncDurableSubs = this.isSyncDurableSubs(); 1633 strategy.appendField(locator, this, "syncDurableSubs", buffer, theSyncDurableSubs); 1634 } 1635 { 1636 Boolean theUseBrokerNameAsIdSees; 1637 theUseBrokerNameAsIdSees = this.isUseBrokerNameAsIdSees(); 1638 strategy.appendField(locator, this, "useBrokerNameAsIdSees", buffer, theUseBrokerNameAsIdSees); 1639 } 1640 { 1641 Boolean theUseCompression; 1642 theUseCompression = this.isUseCompression(); 1643 strategy.appendField(locator, this, "useCompression", buffer, theUseCompression); 1644 } 1645 { 1646 Boolean theUseVirtualDestSubs; 1647 theUseVirtualDestSubs = this.isUseVirtualDestSubs(); 1648 strategy.appendField(locator, this, "useVirtualDestSubs", buffer, theUseVirtualDestSubs); 1649 } 1650 { 1651 String theUserName; 1652 theUserName = this.getUserName(); 1653 strategy.appendField(locator, this, "userName", buffer, theUserName); 1654 } 1655 { 1656 String theId; 1657 theId = this.getId(); 1658 strategy.appendField(locator, this, "id", buffer, theId); 1659 } 1660 return buffer; 1661 } 1662 1663 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1664 int currentHashCode = 1; 1665 { 1666 List<Object> theBridgeOrBridgeFactoryOrBrokerService; 1667 theBridgeOrBridgeFactoryOrBrokerService = (((this.bridgeOrBridgeFactoryOrBrokerService!= null)&&(!this.bridgeOrBridgeFactoryOrBrokerService.isEmpty()))?this.getBridgeOrBridgeFactoryOrBrokerService():null); 1668 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "bridgeOrBridgeFactoryOrBrokerService", theBridgeOrBridgeFactoryOrBrokerService), currentHashCode, theBridgeOrBridgeFactoryOrBrokerService); 1669 } 1670 { 1671 BigInteger theAdvisoryAckPercentage; 1672 theAdvisoryAckPercentage = this.getAdvisoryAckPercentage(); 1673 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "advisoryAckPercentage", theAdvisoryAckPercentage), currentHashCode, theAdvisoryAckPercentage); 1674 } 1675 { 1676 Boolean theAdvisoryForFailedForward; 1677 theAdvisoryForFailedForward = this.isAdvisoryForFailedForward(); 1678 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "advisoryForFailedForward", theAdvisoryForFailedForward), currentHashCode, theAdvisoryForFailedForward); 1679 } 1680 { 1681 BigInteger theAdvisoryPrefetchSize; 1682 theAdvisoryPrefetchSize = this.getAdvisoryPrefetchSize(); 1683 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "advisoryPrefetchSize", theAdvisoryPrefetchSize), currentHashCode, theAdvisoryPrefetchSize); 1684 } 1685 { 1686 Boolean theAlwaysSyncSend; 1687 theAlwaysSyncSend = this.isAlwaysSyncSend(); 1688 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "alwaysSyncSend", theAlwaysSyncSend), currentHashCode, theAlwaysSyncSend); 1689 } 1690 { 1691 String theBridge; 1692 theBridge = this.getBridge(); 1693 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "bridge", theBridge), currentHashCode, theBridge); 1694 } 1695 { 1696 String theBridgeFactory; 1697 theBridgeFactory = this.getBridgeFactory(); 1698 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "bridgeFactory", theBridgeFactory), currentHashCode, theBridgeFactory); 1699 } 1700 { 1701 Boolean theBridgeTempDestinations; 1702 theBridgeTempDestinations = this.isBridgeTempDestinations(); 1703 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "bridgeTempDestinations", theBridgeTempDestinations), currentHashCode, theBridgeTempDestinations); 1704 } 1705 { 1706 String theBrokerName; 1707 theBrokerName = this.getBrokerName(); 1708 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerName", theBrokerName), currentHashCode, theBrokerName); 1709 } 1710 { 1711 String theBrokerService; 1712 theBrokerService = this.getBrokerService(); 1713 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 1714 } 1715 { 1716 String theBrokerURL; 1717 theBrokerURL = this.getBrokerURL(); 1718 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerURL", theBrokerURL), currentHashCode, theBrokerURL); 1719 } 1720 { 1721 Boolean theCheckDuplicateMessagesOnDuplex; 1722 theCheckDuplicateMessagesOnDuplex = this.isCheckDuplicateMessagesOnDuplex(); 1723 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "checkDuplicateMessagesOnDuplex", theCheckDuplicateMessagesOnDuplex), currentHashCode, theCheckDuplicateMessagesOnDuplex); 1724 } 1725 { 1726 String theClientIdToken; 1727 theClientIdToken = this.getClientIdToken(); 1728 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "clientIdToken", theClientIdToken), currentHashCode, theClientIdToken); 1729 } 1730 { 1731 Boolean theConduitNetworkQueueSubscriptions; 1732 theConduitNetworkQueueSubscriptions = this.isConduitNetworkQueueSubscriptions(); 1733 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "conduitNetworkQueueSubscriptions", theConduitNetworkQueueSubscriptions), currentHashCode, theConduitNetworkQueueSubscriptions); 1734 } 1735 { 1736 Boolean theConduitSubscriptions; 1737 theConduitSubscriptions = this.isConduitSubscriptions(); 1738 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "conduitSubscriptions", theConduitSubscriptions), currentHashCode, theConduitSubscriptions); 1739 } 1740 { 1741 String theConnectionFilter; 1742 theConnectionFilter = this.getConnectionFilter(); 1743 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "connectionFilter", theConnectionFilter), currentHashCode, theConnectionFilter); 1744 } 1745 { 1746 BigInteger theConsumerPriorityBase; 1747 theConsumerPriorityBase = this.getConsumerPriorityBase(); 1748 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumerPriorityBase", theConsumerPriorityBase), currentHashCode, theConsumerPriorityBase); 1749 } 1750 { 1751 BigInteger theConsumerTTL; 1752 theConsumerTTL = this.getConsumerTTL(); 1753 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumerTTL", theConsumerTTL), currentHashCode, theConsumerTTL); 1754 } 1755 { 1756 Boolean theDecreaseNetworkConsumerPriority; 1757 theDecreaseNetworkConsumerPriority = this.isDecreaseNetworkConsumerPriority(); 1758 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "decreaseNetworkConsumerPriority", theDecreaseNetworkConsumerPriority), currentHashCode, theDecreaseNetworkConsumerPriority); 1759 } 1760 { 1761 String theDestinationFilter; 1762 theDestinationFilter = this.getDestinationFilter(); 1763 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "destinationFilter", theDestinationFilter), currentHashCode, theDestinationFilter); 1764 } 1765 { 1766 Boolean theDispatchAsync; 1767 theDispatchAsync = this.isDispatchAsync(); 1768 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dispatchAsync", theDispatchAsync), currentHashCode, theDispatchAsync); 1769 } 1770 { 1771 Boolean theDuplex; 1772 theDuplex = this.isDuplex(); 1773 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "duplex", theDuplex), currentHashCode, theDuplex); 1774 } 1775 { 1776 Boolean theDynamicOnly; 1777 theDynamicOnly = this.isDynamicOnly(); 1778 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dynamicOnly", theDynamicOnly), currentHashCode, theDynamicOnly); 1779 } 1780 { 1781 Boolean theGcDestinationViews; 1782 theGcDestinationViews = this.isGcDestinationViews(); 1783 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "gcDestinationViews", theGcDestinationViews), currentHashCode, theGcDestinationViews); 1784 } 1785 { 1786 Long theGcSweepTime; 1787 theGcSweepTime = this.getGcSweepTime(); 1788 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "gcSweepTime", theGcSweepTime), currentHashCode, theGcSweepTime); 1789 } 1790 { 1791 String theLocalTransport; 1792 theLocalTransport = this.getLocalTransport(); 1793 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "localTransport", theLocalTransport), currentHashCode, theLocalTransport); 1794 } 1795 { 1796 String theLocalUri; 1797 theLocalUri = this.getLocalUri(); 1798 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "localUri", theLocalUri), currentHashCode, theLocalUri); 1799 } 1800 { 1801 BigInteger theMessageTTL; 1802 theMessageTTL = this.getMessageTTL(); 1803 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "messageTTL", theMessageTTL), currentHashCode, theMessageTTL); 1804 } 1805 { 1806 String theName; 1807 theName = this.getName(); 1808 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "name", theName), currentHashCode, theName); 1809 } 1810 { 1811 BigInteger theNetworkTTL; 1812 theNetworkTTL = this.getNetworkTTL(); 1813 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "networkTTL", theNetworkTTL), currentHashCode, theNetworkTTL); 1814 } 1815 { 1816 String theObjectName; 1817 theObjectName = this.getObjectName(); 1818 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "objectName", theObjectName), currentHashCode, theObjectName); 1819 } 1820 { 1821 String thePassword; 1822 thePassword = this.getPassword(); 1823 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "password", thePassword), currentHashCode, thePassword); 1824 } 1825 { 1826 String thePrefetchSize; 1827 thePrefetchSize = this.getPrefetchSize(); 1828 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "prefetchSize", thePrefetchSize), currentHashCode, thePrefetchSize); 1829 } 1830 { 1831 String theRemoteTransport; 1832 theRemoteTransport = this.getRemoteTransport(); 1833 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "remoteTransport", theRemoteTransport), currentHashCode, theRemoteTransport); 1834 } 1835 { 1836 String theRemoteURI; 1837 theRemoteURI = this.getRemoteURI(); 1838 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "remoteURI", theRemoteURI), currentHashCode, theRemoteURI); 1839 } 1840 { 1841 Boolean theStaticBridge; 1842 theStaticBridge = this.isStaticBridge(); 1843 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "staticBridge", theStaticBridge), currentHashCode, theStaticBridge); 1844 } 1845 { 1846 Boolean theSuppressDuplicateQueueSubscriptions; 1847 theSuppressDuplicateQueueSubscriptions = this.isSuppressDuplicateQueueSubscriptions(); 1848 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "suppressDuplicateQueueSubscriptions", theSuppressDuplicateQueueSubscriptions), currentHashCode, theSuppressDuplicateQueueSubscriptions); 1849 } 1850 { 1851 Boolean theSuppressDuplicateTopicSubscriptions; 1852 theSuppressDuplicateTopicSubscriptions = this.isSuppressDuplicateTopicSubscriptions(); 1853 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "suppressDuplicateTopicSubscriptions", theSuppressDuplicateTopicSubscriptions), currentHashCode, theSuppressDuplicateTopicSubscriptions); 1854 } 1855 { 1856 Boolean theSyncDurableSubs; 1857 theSyncDurableSubs = this.isSyncDurableSubs(); 1858 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "syncDurableSubs", theSyncDurableSubs), currentHashCode, theSyncDurableSubs); 1859 } 1860 { 1861 Boolean theUseBrokerNameAsIdSees; 1862 theUseBrokerNameAsIdSees = this.isUseBrokerNameAsIdSees(); 1863 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useBrokerNameAsIdSees", theUseBrokerNameAsIdSees), currentHashCode, theUseBrokerNameAsIdSees); 1864 } 1865 { 1866 Boolean theUseCompression; 1867 theUseCompression = this.isUseCompression(); 1868 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useCompression", theUseCompression), currentHashCode, theUseCompression); 1869 } 1870 { 1871 Boolean theUseVirtualDestSubs; 1872 theUseVirtualDestSubs = this.isUseVirtualDestSubs(); 1873 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useVirtualDestSubs", theUseVirtualDestSubs), currentHashCode, theUseVirtualDestSubs); 1874 } 1875 { 1876 String theUserName; 1877 theUserName = this.getUserName(); 1878 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "userName", theUserName), currentHashCode, theUserName); 1879 } 1880 { 1881 String theId; 1882 theId = this.getId(); 1883 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 1884 } 1885 return currentHashCode; 1886 } 1887 1888 public int hashCode() { 1889 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1890 return this.hashCode(null, strategy); 1891 } 1892 1893 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1894 if (!(object instanceof DtoMulticastNetworkConnector)) { 1895 return false; 1896 } 1897 if (this == object) { 1898 return true; 1899 } 1900 final DtoMulticastNetworkConnector that = ((DtoMulticastNetworkConnector) object); 1901 { 1902 List<Object> lhsBridgeOrBridgeFactoryOrBrokerService; 1903 lhsBridgeOrBridgeFactoryOrBrokerService = (((this.bridgeOrBridgeFactoryOrBrokerService!= null)&&(!this.bridgeOrBridgeFactoryOrBrokerService.isEmpty()))?this.getBridgeOrBridgeFactoryOrBrokerService():null); 1904 List<Object> rhsBridgeOrBridgeFactoryOrBrokerService; 1905 rhsBridgeOrBridgeFactoryOrBrokerService = (((that.bridgeOrBridgeFactoryOrBrokerService!= null)&&(!that.bridgeOrBridgeFactoryOrBrokerService.isEmpty()))?that.getBridgeOrBridgeFactoryOrBrokerService():null); 1906 if (!strategy.equals(LocatorUtils.property(thisLocator, "bridgeOrBridgeFactoryOrBrokerService", lhsBridgeOrBridgeFactoryOrBrokerService), LocatorUtils.property(thatLocator, "bridgeOrBridgeFactoryOrBrokerService", rhsBridgeOrBridgeFactoryOrBrokerService), lhsBridgeOrBridgeFactoryOrBrokerService, rhsBridgeOrBridgeFactoryOrBrokerService)) { 1907 return false; 1908 } 1909 } 1910 { 1911 BigInteger lhsAdvisoryAckPercentage; 1912 lhsAdvisoryAckPercentage = this.getAdvisoryAckPercentage(); 1913 BigInteger rhsAdvisoryAckPercentage; 1914 rhsAdvisoryAckPercentage = that.getAdvisoryAckPercentage(); 1915 if (!strategy.equals(LocatorUtils.property(thisLocator, "advisoryAckPercentage", lhsAdvisoryAckPercentage), LocatorUtils.property(thatLocator, "advisoryAckPercentage", rhsAdvisoryAckPercentage), lhsAdvisoryAckPercentage, rhsAdvisoryAckPercentage)) { 1916 return false; 1917 } 1918 } 1919 { 1920 Boolean lhsAdvisoryForFailedForward; 1921 lhsAdvisoryForFailedForward = this.isAdvisoryForFailedForward(); 1922 Boolean rhsAdvisoryForFailedForward; 1923 rhsAdvisoryForFailedForward = that.isAdvisoryForFailedForward(); 1924 if (!strategy.equals(LocatorUtils.property(thisLocator, "advisoryForFailedForward", lhsAdvisoryForFailedForward), LocatorUtils.property(thatLocator, "advisoryForFailedForward", rhsAdvisoryForFailedForward), lhsAdvisoryForFailedForward, rhsAdvisoryForFailedForward)) { 1925 return false; 1926 } 1927 } 1928 { 1929 BigInteger lhsAdvisoryPrefetchSize; 1930 lhsAdvisoryPrefetchSize = this.getAdvisoryPrefetchSize(); 1931 BigInteger rhsAdvisoryPrefetchSize; 1932 rhsAdvisoryPrefetchSize = that.getAdvisoryPrefetchSize(); 1933 if (!strategy.equals(LocatorUtils.property(thisLocator, "advisoryPrefetchSize", lhsAdvisoryPrefetchSize), LocatorUtils.property(thatLocator, "advisoryPrefetchSize", rhsAdvisoryPrefetchSize), lhsAdvisoryPrefetchSize, rhsAdvisoryPrefetchSize)) { 1934 return false; 1935 } 1936 } 1937 { 1938 Boolean lhsAlwaysSyncSend; 1939 lhsAlwaysSyncSend = this.isAlwaysSyncSend(); 1940 Boolean rhsAlwaysSyncSend; 1941 rhsAlwaysSyncSend = that.isAlwaysSyncSend(); 1942 if (!strategy.equals(LocatorUtils.property(thisLocator, "alwaysSyncSend", lhsAlwaysSyncSend), LocatorUtils.property(thatLocator, "alwaysSyncSend", rhsAlwaysSyncSend), lhsAlwaysSyncSend, rhsAlwaysSyncSend)) { 1943 return false; 1944 } 1945 } 1946 { 1947 String lhsBridge; 1948 lhsBridge = this.getBridge(); 1949 String rhsBridge; 1950 rhsBridge = that.getBridge(); 1951 if (!strategy.equals(LocatorUtils.property(thisLocator, "bridge", lhsBridge), LocatorUtils.property(thatLocator, "bridge", rhsBridge), lhsBridge, rhsBridge)) { 1952 return false; 1953 } 1954 } 1955 { 1956 String lhsBridgeFactory; 1957 lhsBridgeFactory = this.getBridgeFactory(); 1958 String rhsBridgeFactory; 1959 rhsBridgeFactory = that.getBridgeFactory(); 1960 if (!strategy.equals(LocatorUtils.property(thisLocator, "bridgeFactory", lhsBridgeFactory), LocatorUtils.property(thatLocator, "bridgeFactory", rhsBridgeFactory), lhsBridgeFactory, rhsBridgeFactory)) { 1961 return false; 1962 } 1963 } 1964 { 1965 Boolean lhsBridgeTempDestinations; 1966 lhsBridgeTempDestinations = this.isBridgeTempDestinations(); 1967 Boolean rhsBridgeTempDestinations; 1968 rhsBridgeTempDestinations = that.isBridgeTempDestinations(); 1969 if (!strategy.equals(LocatorUtils.property(thisLocator, "bridgeTempDestinations", lhsBridgeTempDestinations), LocatorUtils.property(thatLocator, "bridgeTempDestinations", rhsBridgeTempDestinations), lhsBridgeTempDestinations, rhsBridgeTempDestinations)) { 1970 return false; 1971 } 1972 } 1973 { 1974 String lhsBrokerName; 1975 lhsBrokerName = this.getBrokerName(); 1976 String rhsBrokerName; 1977 rhsBrokerName = that.getBrokerName(); 1978 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerName", lhsBrokerName), LocatorUtils.property(thatLocator, "brokerName", rhsBrokerName), lhsBrokerName, rhsBrokerName)) { 1979 return false; 1980 } 1981 } 1982 { 1983 String lhsBrokerService; 1984 lhsBrokerService = this.getBrokerService(); 1985 String rhsBrokerService; 1986 rhsBrokerService = that.getBrokerService(); 1987 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 1988 return false; 1989 } 1990 } 1991 { 1992 String lhsBrokerURL; 1993 lhsBrokerURL = this.getBrokerURL(); 1994 String rhsBrokerURL; 1995 rhsBrokerURL = that.getBrokerURL(); 1996 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerURL", lhsBrokerURL), LocatorUtils.property(thatLocator, "brokerURL", rhsBrokerURL), lhsBrokerURL, rhsBrokerURL)) { 1997 return false; 1998 } 1999 } 2000 { 2001 Boolean lhsCheckDuplicateMessagesOnDuplex; 2002 lhsCheckDuplicateMessagesOnDuplex = this.isCheckDuplicateMessagesOnDuplex(); 2003 Boolean rhsCheckDuplicateMessagesOnDuplex; 2004 rhsCheckDuplicateMessagesOnDuplex = that.isCheckDuplicateMessagesOnDuplex(); 2005 if (!strategy.equals(LocatorUtils.property(thisLocator, "checkDuplicateMessagesOnDuplex", lhsCheckDuplicateMessagesOnDuplex), LocatorUtils.property(thatLocator, "checkDuplicateMessagesOnDuplex", rhsCheckDuplicateMessagesOnDuplex), lhsCheckDuplicateMessagesOnDuplex, rhsCheckDuplicateMessagesOnDuplex)) { 2006 return false; 2007 } 2008 } 2009 { 2010 String lhsClientIdToken; 2011 lhsClientIdToken = this.getClientIdToken(); 2012 String rhsClientIdToken; 2013 rhsClientIdToken = that.getClientIdToken(); 2014 if (!strategy.equals(LocatorUtils.property(thisLocator, "clientIdToken", lhsClientIdToken), LocatorUtils.property(thatLocator, "clientIdToken", rhsClientIdToken), lhsClientIdToken, rhsClientIdToken)) { 2015 return false; 2016 } 2017 } 2018 { 2019 Boolean lhsConduitNetworkQueueSubscriptions; 2020 lhsConduitNetworkQueueSubscriptions = this.isConduitNetworkQueueSubscriptions(); 2021 Boolean rhsConduitNetworkQueueSubscriptions; 2022 rhsConduitNetworkQueueSubscriptions = that.isConduitNetworkQueueSubscriptions(); 2023 if (!strategy.equals(LocatorUtils.property(thisLocator, "conduitNetworkQueueSubscriptions", lhsConduitNetworkQueueSubscriptions), LocatorUtils.property(thatLocator, "conduitNetworkQueueSubscriptions", rhsConduitNetworkQueueSubscriptions), lhsConduitNetworkQueueSubscriptions, rhsConduitNetworkQueueSubscriptions)) { 2024 return false; 2025 } 2026 } 2027 { 2028 Boolean lhsConduitSubscriptions; 2029 lhsConduitSubscriptions = this.isConduitSubscriptions(); 2030 Boolean rhsConduitSubscriptions; 2031 rhsConduitSubscriptions = that.isConduitSubscriptions(); 2032 if (!strategy.equals(LocatorUtils.property(thisLocator, "conduitSubscriptions", lhsConduitSubscriptions), LocatorUtils.property(thatLocator, "conduitSubscriptions", rhsConduitSubscriptions), lhsConduitSubscriptions, rhsConduitSubscriptions)) { 2033 return false; 2034 } 2035 } 2036 { 2037 String lhsConnectionFilter; 2038 lhsConnectionFilter = this.getConnectionFilter(); 2039 String rhsConnectionFilter; 2040 rhsConnectionFilter = that.getConnectionFilter(); 2041 if (!strategy.equals(LocatorUtils.property(thisLocator, "connectionFilter", lhsConnectionFilter), LocatorUtils.property(thatLocator, "connectionFilter", rhsConnectionFilter), lhsConnectionFilter, rhsConnectionFilter)) { 2042 return false; 2043 } 2044 } 2045 { 2046 BigInteger lhsConsumerPriorityBase; 2047 lhsConsumerPriorityBase = this.getConsumerPriorityBase(); 2048 BigInteger rhsConsumerPriorityBase; 2049 rhsConsumerPriorityBase = that.getConsumerPriorityBase(); 2050 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumerPriorityBase", lhsConsumerPriorityBase), LocatorUtils.property(thatLocator, "consumerPriorityBase", rhsConsumerPriorityBase), lhsConsumerPriorityBase, rhsConsumerPriorityBase)) { 2051 return false; 2052 } 2053 } 2054 { 2055 BigInteger lhsConsumerTTL; 2056 lhsConsumerTTL = this.getConsumerTTL(); 2057 BigInteger rhsConsumerTTL; 2058 rhsConsumerTTL = that.getConsumerTTL(); 2059 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumerTTL", lhsConsumerTTL), LocatorUtils.property(thatLocator, "consumerTTL", rhsConsumerTTL), lhsConsumerTTL, rhsConsumerTTL)) { 2060 return false; 2061 } 2062 } 2063 { 2064 Boolean lhsDecreaseNetworkConsumerPriority; 2065 lhsDecreaseNetworkConsumerPriority = this.isDecreaseNetworkConsumerPriority(); 2066 Boolean rhsDecreaseNetworkConsumerPriority; 2067 rhsDecreaseNetworkConsumerPriority = that.isDecreaseNetworkConsumerPriority(); 2068 if (!strategy.equals(LocatorUtils.property(thisLocator, "decreaseNetworkConsumerPriority", lhsDecreaseNetworkConsumerPriority), LocatorUtils.property(thatLocator, "decreaseNetworkConsumerPriority", rhsDecreaseNetworkConsumerPriority), lhsDecreaseNetworkConsumerPriority, rhsDecreaseNetworkConsumerPriority)) { 2069 return false; 2070 } 2071 } 2072 { 2073 String lhsDestinationFilter; 2074 lhsDestinationFilter = this.getDestinationFilter(); 2075 String rhsDestinationFilter; 2076 rhsDestinationFilter = that.getDestinationFilter(); 2077 if (!strategy.equals(LocatorUtils.property(thisLocator, "destinationFilter", lhsDestinationFilter), LocatorUtils.property(thatLocator, "destinationFilter", rhsDestinationFilter), lhsDestinationFilter, rhsDestinationFilter)) { 2078 return false; 2079 } 2080 } 2081 { 2082 Boolean lhsDispatchAsync; 2083 lhsDispatchAsync = this.isDispatchAsync(); 2084 Boolean rhsDispatchAsync; 2085 rhsDispatchAsync = that.isDispatchAsync(); 2086 if (!strategy.equals(LocatorUtils.property(thisLocator, "dispatchAsync", lhsDispatchAsync), LocatorUtils.property(thatLocator, "dispatchAsync", rhsDispatchAsync), lhsDispatchAsync, rhsDispatchAsync)) { 2087 return false; 2088 } 2089 } 2090 { 2091 Boolean lhsDuplex; 2092 lhsDuplex = this.isDuplex(); 2093 Boolean rhsDuplex; 2094 rhsDuplex = that.isDuplex(); 2095 if (!strategy.equals(LocatorUtils.property(thisLocator, "duplex", lhsDuplex), LocatorUtils.property(thatLocator, "duplex", rhsDuplex), lhsDuplex, rhsDuplex)) { 2096 return false; 2097 } 2098 } 2099 { 2100 Boolean lhsDynamicOnly; 2101 lhsDynamicOnly = this.isDynamicOnly(); 2102 Boolean rhsDynamicOnly; 2103 rhsDynamicOnly = that.isDynamicOnly(); 2104 if (!strategy.equals(LocatorUtils.property(thisLocator, "dynamicOnly", lhsDynamicOnly), LocatorUtils.property(thatLocator, "dynamicOnly", rhsDynamicOnly), lhsDynamicOnly, rhsDynamicOnly)) { 2105 return false; 2106 } 2107 } 2108 { 2109 Boolean lhsGcDestinationViews; 2110 lhsGcDestinationViews = this.isGcDestinationViews(); 2111 Boolean rhsGcDestinationViews; 2112 rhsGcDestinationViews = that.isGcDestinationViews(); 2113 if (!strategy.equals(LocatorUtils.property(thisLocator, "gcDestinationViews", lhsGcDestinationViews), LocatorUtils.property(thatLocator, "gcDestinationViews", rhsGcDestinationViews), lhsGcDestinationViews, rhsGcDestinationViews)) { 2114 return false; 2115 } 2116 } 2117 { 2118 Long lhsGcSweepTime; 2119 lhsGcSweepTime = this.getGcSweepTime(); 2120 Long rhsGcSweepTime; 2121 rhsGcSweepTime = that.getGcSweepTime(); 2122 if (!strategy.equals(LocatorUtils.property(thisLocator, "gcSweepTime", lhsGcSweepTime), LocatorUtils.property(thatLocator, "gcSweepTime", rhsGcSweepTime), lhsGcSweepTime, rhsGcSweepTime)) { 2123 return false; 2124 } 2125 } 2126 { 2127 String lhsLocalTransport; 2128 lhsLocalTransport = this.getLocalTransport(); 2129 String rhsLocalTransport; 2130 rhsLocalTransport = that.getLocalTransport(); 2131 if (!strategy.equals(LocatorUtils.property(thisLocator, "localTransport", lhsLocalTransport), LocatorUtils.property(thatLocator, "localTransport", rhsLocalTransport), lhsLocalTransport, rhsLocalTransport)) { 2132 return false; 2133 } 2134 } 2135 { 2136 String lhsLocalUri; 2137 lhsLocalUri = this.getLocalUri(); 2138 String rhsLocalUri; 2139 rhsLocalUri = that.getLocalUri(); 2140 if (!strategy.equals(LocatorUtils.property(thisLocator, "localUri", lhsLocalUri), LocatorUtils.property(thatLocator, "localUri", rhsLocalUri), lhsLocalUri, rhsLocalUri)) { 2141 return false; 2142 } 2143 } 2144 { 2145 BigInteger lhsMessageTTL; 2146 lhsMessageTTL = this.getMessageTTL(); 2147 BigInteger rhsMessageTTL; 2148 rhsMessageTTL = that.getMessageTTL(); 2149 if (!strategy.equals(LocatorUtils.property(thisLocator, "messageTTL", lhsMessageTTL), LocatorUtils.property(thatLocator, "messageTTL", rhsMessageTTL), lhsMessageTTL, rhsMessageTTL)) { 2150 return false; 2151 } 2152 } 2153 { 2154 String lhsName; 2155 lhsName = this.getName(); 2156 String rhsName; 2157 rhsName = that.getName(); 2158 if (!strategy.equals(LocatorUtils.property(thisLocator, "name", lhsName), LocatorUtils.property(thatLocator, "name", rhsName), lhsName, rhsName)) { 2159 return false; 2160 } 2161 } 2162 { 2163 BigInteger lhsNetworkTTL; 2164 lhsNetworkTTL = this.getNetworkTTL(); 2165 BigInteger rhsNetworkTTL; 2166 rhsNetworkTTL = that.getNetworkTTL(); 2167 if (!strategy.equals(LocatorUtils.property(thisLocator, "networkTTL", lhsNetworkTTL), LocatorUtils.property(thatLocator, "networkTTL", rhsNetworkTTL), lhsNetworkTTL, rhsNetworkTTL)) { 2168 return false; 2169 } 2170 } 2171 { 2172 String lhsObjectName; 2173 lhsObjectName = this.getObjectName(); 2174 String rhsObjectName; 2175 rhsObjectName = that.getObjectName(); 2176 if (!strategy.equals(LocatorUtils.property(thisLocator, "objectName", lhsObjectName), LocatorUtils.property(thatLocator, "objectName", rhsObjectName), lhsObjectName, rhsObjectName)) { 2177 return false; 2178 } 2179 } 2180 { 2181 String lhsPassword; 2182 lhsPassword = this.getPassword(); 2183 String rhsPassword; 2184 rhsPassword = that.getPassword(); 2185 if (!strategy.equals(LocatorUtils.property(thisLocator, "password", lhsPassword), LocatorUtils.property(thatLocator, "password", rhsPassword), lhsPassword, rhsPassword)) { 2186 return false; 2187 } 2188 } 2189 { 2190 String lhsPrefetchSize; 2191 lhsPrefetchSize = this.getPrefetchSize(); 2192 String rhsPrefetchSize; 2193 rhsPrefetchSize = that.getPrefetchSize(); 2194 if (!strategy.equals(LocatorUtils.property(thisLocator, "prefetchSize", lhsPrefetchSize), LocatorUtils.property(thatLocator, "prefetchSize", rhsPrefetchSize), lhsPrefetchSize, rhsPrefetchSize)) { 2195 return false; 2196 } 2197 } 2198 { 2199 String lhsRemoteTransport; 2200 lhsRemoteTransport = this.getRemoteTransport(); 2201 String rhsRemoteTransport; 2202 rhsRemoteTransport = that.getRemoteTransport(); 2203 if (!strategy.equals(LocatorUtils.property(thisLocator, "remoteTransport", lhsRemoteTransport), LocatorUtils.property(thatLocator, "remoteTransport", rhsRemoteTransport), lhsRemoteTransport, rhsRemoteTransport)) { 2204 return false; 2205 } 2206 } 2207 { 2208 String lhsRemoteURI; 2209 lhsRemoteURI = this.getRemoteURI(); 2210 String rhsRemoteURI; 2211 rhsRemoteURI = that.getRemoteURI(); 2212 if (!strategy.equals(LocatorUtils.property(thisLocator, "remoteURI", lhsRemoteURI), LocatorUtils.property(thatLocator, "remoteURI", rhsRemoteURI), lhsRemoteURI, rhsRemoteURI)) { 2213 return false; 2214 } 2215 } 2216 { 2217 Boolean lhsStaticBridge; 2218 lhsStaticBridge = this.isStaticBridge(); 2219 Boolean rhsStaticBridge; 2220 rhsStaticBridge = that.isStaticBridge(); 2221 if (!strategy.equals(LocatorUtils.property(thisLocator, "staticBridge", lhsStaticBridge), LocatorUtils.property(thatLocator, "staticBridge", rhsStaticBridge), lhsStaticBridge, rhsStaticBridge)) { 2222 return false; 2223 } 2224 } 2225 { 2226 Boolean lhsSuppressDuplicateQueueSubscriptions; 2227 lhsSuppressDuplicateQueueSubscriptions = this.isSuppressDuplicateQueueSubscriptions(); 2228 Boolean rhsSuppressDuplicateQueueSubscriptions; 2229 rhsSuppressDuplicateQueueSubscriptions = that.isSuppressDuplicateQueueSubscriptions(); 2230 if (!strategy.equals(LocatorUtils.property(thisLocator, "suppressDuplicateQueueSubscriptions", lhsSuppressDuplicateQueueSubscriptions), LocatorUtils.property(thatLocator, "suppressDuplicateQueueSubscriptions", rhsSuppressDuplicateQueueSubscriptions), lhsSuppressDuplicateQueueSubscriptions, rhsSuppressDuplicateQueueSubscriptions)) { 2231 return false; 2232 } 2233 } 2234 { 2235 Boolean lhsSuppressDuplicateTopicSubscriptions; 2236 lhsSuppressDuplicateTopicSubscriptions = this.isSuppressDuplicateTopicSubscriptions(); 2237 Boolean rhsSuppressDuplicateTopicSubscriptions; 2238 rhsSuppressDuplicateTopicSubscriptions = that.isSuppressDuplicateTopicSubscriptions(); 2239 if (!strategy.equals(LocatorUtils.property(thisLocator, "suppressDuplicateTopicSubscriptions", lhsSuppressDuplicateTopicSubscriptions), LocatorUtils.property(thatLocator, "suppressDuplicateTopicSubscriptions", rhsSuppressDuplicateTopicSubscriptions), lhsSuppressDuplicateTopicSubscriptions, rhsSuppressDuplicateTopicSubscriptions)) { 2240 return false; 2241 } 2242 } 2243 { 2244 Boolean lhsSyncDurableSubs; 2245 lhsSyncDurableSubs = this.isSyncDurableSubs(); 2246 Boolean rhsSyncDurableSubs; 2247 rhsSyncDurableSubs = that.isSyncDurableSubs(); 2248 if (!strategy.equals(LocatorUtils.property(thisLocator, "syncDurableSubs", lhsSyncDurableSubs), LocatorUtils.property(thatLocator, "syncDurableSubs", rhsSyncDurableSubs), lhsSyncDurableSubs, rhsSyncDurableSubs)) { 2249 return false; 2250 } 2251 } 2252 { 2253 Boolean lhsUseBrokerNameAsIdSees; 2254 lhsUseBrokerNameAsIdSees = this.isUseBrokerNameAsIdSees(); 2255 Boolean rhsUseBrokerNameAsIdSees; 2256 rhsUseBrokerNameAsIdSees = that.isUseBrokerNameAsIdSees(); 2257 if (!strategy.equals(LocatorUtils.property(thisLocator, "useBrokerNameAsIdSees", lhsUseBrokerNameAsIdSees), LocatorUtils.property(thatLocator, "useBrokerNameAsIdSees", rhsUseBrokerNameAsIdSees), lhsUseBrokerNameAsIdSees, rhsUseBrokerNameAsIdSees)) { 2258 return false; 2259 } 2260 } 2261 { 2262 Boolean lhsUseCompression; 2263 lhsUseCompression = this.isUseCompression(); 2264 Boolean rhsUseCompression; 2265 rhsUseCompression = that.isUseCompression(); 2266 if (!strategy.equals(LocatorUtils.property(thisLocator, "useCompression", lhsUseCompression), LocatorUtils.property(thatLocator, "useCompression", rhsUseCompression), lhsUseCompression, rhsUseCompression)) { 2267 return false; 2268 } 2269 } 2270 { 2271 Boolean lhsUseVirtualDestSubs; 2272 lhsUseVirtualDestSubs = this.isUseVirtualDestSubs(); 2273 Boolean rhsUseVirtualDestSubs; 2274 rhsUseVirtualDestSubs = that.isUseVirtualDestSubs(); 2275 if (!strategy.equals(LocatorUtils.property(thisLocator, "useVirtualDestSubs", lhsUseVirtualDestSubs), LocatorUtils.property(thatLocator, "useVirtualDestSubs", rhsUseVirtualDestSubs), lhsUseVirtualDestSubs, rhsUseVirtualDestSubs)) { 2276 return false; 2277 } 2278 } 2279 { 2280 String lhsUserName; 2281 lhsUserName = this.getUserName(); 2282 String rhsUserName; 2283 rhsUserName = that.getUserName(); 2284 if (!strategy.equals(LocatorUtils.property(thisLocator, "userName", lhsUserName), LocatorUtils.property(thatLocator, "userName", rhsUserName), lhsUserName, rhsUserName)) { 2285 return false; 2286 } 2287 } 2288 { 2289 String lhsId; 2290 lhsId = this.getId(); 2291 String rhsId; 2292 rhsId = that.getId(); 2293 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 2294 return false; 2295 } 2296 } 2297 return true; 2298 } 2299 2300 public boolean equals(Object object) { 2301 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2302 return equals(null, null, object, strategy); 2303 } 2304 2305 2306 /** 2307 * <p>Java class for anonymous complex type. 2308 * 2309 * <p>The following schema fragment specifies the expected content contained within this class. 2310 * 2311 * <pre> 2312 * <complexType> 2313 * <complexContent> 2314 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2315 * <choice minOccurs="0"> 2316 * <element ref="{http://activemq.apache.org/schema/core}compositeDemandForwardingBridge"/> 2317 * <element ref="{http://activemq.apache.org/schema/core}demandForwardingBridge"/> 2318 * <any namespace='##other'/> 2319 * </choice> 2320 * </restriction> 2321 * </complexContent> 2322 * </complexType> 2323 * </pre> 2324 * 2325 * 2326 */ 2327 @XmlAccessorType(XmlAccessType.FIELD) 2328 @XmlType(name = "", propOrder = { 2329 "compositeDemandForwardingBridge", 2330 "demandForwardingBridge", 2331 "any" 2332 }) 2333 public static class Bridge 2334 implements Equals, HashCode, ToString 2335 { 2336 2337 protected DtoCompositeDemandForwardingBridge compositeDemandForwardingBridge; 2338 protected DtoDemandForwardingBridge demandForwardingBridge; 2339 @XmlAnyElement(lax = true) 2340 protected Object any; 2341 2342 /** 2343 * Gets the value of the compositeDemandForwardingBridge property. 2344 * 2345 * @return 2346 * possible object is 2347 * {@link DtoCompositeDemandForwardingBridge } 2348 * 2349 */ 2350 public DtoCompositeDemandForwardingBridge getCompositeDemandForwardingBridge() { 2351 return compositeDemandForwardingBridge; 2352 } 2353 2354 /** 2355 * Sets the value of the compositeDemandForwardingBridge property. 2356 * 2357 * @param value 2358 * allowed object is 2359 * {@link DtoCompositeDemandForwardingBridge } 2360 * 2361 */ 2362 public void setCompositeDemandForwardingBridge(DtoCompositeDemandForwardingBridge value) { 2363 this.compositeDemandForwardingBridge = value; 2364 } 2365 2366 /** 2367 * Gets the value of the demandForwardingBridge property. 2368 * 2369 * @return 2370 * possible object is 2371 * {@link DtoDemandForwardingBridge } 2372 * 2373 */ 2374 public DtoDemandForwardingBridge getDemandForwardingBridge() { 2375 return demandForwardingBridge; 2376 } 2377 2378 /** 2379 * Sets the value of the demandForwardingBridge property. 2380 * 2381 * @param value 2382 * allowed object is 2383 * {@link DtoDemandForwardingBridge } 2384 * 2385 */ 2386 public void setDemandForwardingBridge(DtoDemandForwardingBridge value) { 2387 this.demandForwardingBridge = value; 2388 } 2389 2390 /** 2391 * Gets the value of the any property. 2392 * 2393 * @return 2394 * possible object is 2395 * {@link Object } 2396 * 2397 */ 2398 public Object getAny() { 2399 return any; 2400 } 2401 2402 /** 2403 * Sets the value of the any property. 2404 * 2405 * @param value 2406 * allowed object is 2407 * {@link Object } 2408 * 2409 */ 2410 public void setAny(Object value) { 2411 this.any = value; 2412 } 2413 2414 public String toString() { 2415 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2416 final StringBuilder buffer = new StringBuilder(); 2417 append(null, buffer, strategy); 2418 return buffer.toString(); 2419 } 2420 2421 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2422 strategy.appendStart(locator, this, buffer); 2423 appendFields(locator, buffer, strategy); 2424 strategy.appendEnd(locator, this, buffer); 2425 return buffer; 2426 } 2427 2428 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2429 { 2430 DtoCompositeDemandForwardingBridge theCompositeDemandForwardingBridge; 2431 theCompositeDemandForwardingBridge = this.getCompositeDemandForwardingBridge(); 2432 strategy.appendField(locator, this, "compositeDemandForwardingBridge", buffer, theCompositeDemandForwardingBridge); 2433 } 2434 { 2435 DtoDemandForwardingBridge theDemandForwardingBridge; 2436 theDemandForwardingBridge = this.getDemandForwardingBridge(); 2437 strategy.appendField(locator, this, "demandForwardingBridge", buffer, theDemandForwardingBridge); 2438 } 2439 { 2440 Object theAny; 2441 theAny = this.getAny(); 2442 strategy.appendField(locator, this, "any", buffer, theAny); 2443 } 2444 return buffer; 2445 } 2446 2447 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2448 int currentHashCode = 1; 2449 { 2450 DtoCompositeDemandForwardingBridge theCompositeDemandForwardingBridge; 2451 theCompositeDemandForwardingBridge = this.getCompositeDemandForwardingBridge(); 2452 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "compositeDemandForwardingBridge", theCompositeDemandForwardingBridge), currentHashCode, theCompositeDemandForwardingBridge); 2453 } 2454 { 2455 DtoDemandForwardingBridge theDemandForwardingBridge; 2456 theDemandForwardingBridge = this.getDemandForwardingBridge(); 2457 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "demandForwardingBridge", theDemandForwardingBridge), currentHashCode, theDemandForwardingBridge); 2458 } 2459 { 2460 Object theAny; 2461 theAny = this.getAny(); 2462 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2463 } 2464 return currentHashCode; 2465 } 2466 2467 public int hashCode() { 2468 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2469 return this.hashCode(null, strategy); 2470 } 2471 2472 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2473 if (!(object instanceof DtoMulticastNetworkConnector.Bridge)) { 2474 return false; 2475 } 2476 if (this == object) { 2477 return true; 2478 } 2479 final DtoMulticastNetworkConnector.Bridge that = ((DtoMulticastNetworkConnector.Bridge) object); 2480 { 2481 DtoCompositeDemandForwardingBridge lhsCompositeDemandForwardingBridge; 2482 lhsCompositeDemandForwardingBridge = this.getCompositeDemandForwardingBridge(); 2483 DtoCompositeDemandForwardingBridge rhsCompositeDemandForwardingBridge; 2484 rhsCompositeDemandForwardingBridge = that.getCompositeDemandForwardingBridge(); 2485 if (!strategy.equals(LocatorUtils.property(thisLocator, "compositeDemandForwardingBridge", lhsCompositeDemandForwardingBridge), LocatorUtils.property(thatLocator, "compositeDemandForwardingBridge", rhsCompositeDemandForwardingBridge), lhsCompositeDemandForwardingBridge, rhsCompositeDemandForwardingBridge)) { 2486 return false; 2487 } 2488 } 2489 { 2490 DtoDemandForwardingBridge lhsDemandForwardingBridge; 2491 lhsDemandForwardingBridge = this.getDemandForwardingBridge(); 2492 DtoDemandForwardingBridge rhsDemandForwardingBridge; 2493 rhsDemandForwardingBridge = that.getDemandForwardingBridge(); 2494 if (!strategy.equals(LocatorUtils.property(thisLocator, "demandForwardingBridge", lhsDemandForwardingBridge), LocatorUtils.property(thatLocator, "demandForwardingBridge", rhsDemandForwardingBridge), lhsDemandForwardingBridge, rhsDemandForwardingBridge)) { 2495 return false; 2496 } 2497 } 2498 { 2499 Object lhsAny; 2500 lhsAny = this.getAny(); 2501 Object rhsAny; 2502 rhsAny = that.getAny(); 2503 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2504 return false; 2505 } 2506 } 2507 return true; 2508 } 2509 2510 public boolean equals(Object object) { 2511 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2512 return equals(null, null, object, strategy); 2513 } 2514 2515 } 2516 2517 2518 /** 2519 * <p>Java class for anonymous complex type. 2520 * 2521 * <p>The following schema fragment specifies the expected content contained within this class. 2522 * 2523 * <pre> 2524 * <complexType> 2525 * <complexContent> 2526 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2527 * <sequence minOccurs="0"> 2528 * <any maxOccurs="unbounded" minOccurs="0"/> 2529 * </sequence> 2530 * </restriction> 2531 * </complexContent> 2532 * </complexType> 2533 * </pre> 2534 * 2535 * 2536 */ 2537 @XmlAccessorType(XmlAccessType.FIELD) 2538 @XmlType(name = "", propOrder = { 2539 "any" 2540 }) 2541 public static class BridgeFactory 2542 implements Equals, HashCode, ToString 2543 { 2544 2545 @XmlAnyElement(lax = true) 2546 protected List<Object> any; 2547 2548 /** 2549 * Gets the value of the any property. 2550 * 2551 * <p> 2552 * This accessor method returns a reference to the live list, 2553 * not a snapshot. Therefore any modification you make to the 2554 * returned list will be present inside the JAXB object. 2555 * This is why there is not a <CODE>set</CODE> method for the any property. 2556 * 2557 * <p> 2558 * For example, to add a new item, do as follows: 2559 * <pre> 2560 * getAny().add(newItem); 2561 * </pre> 2562 * 2563 * 2564 * <p> 2565 * Objects of the following type(s) are allowed in the list 2566 * {@link Object } 2567 * 2568 * 2569 */ 2570 public List<Object> getAny() { 2571 if (any == null) { 2572 any = new ArrayList<Object>(); 2573 } 2574 return this.any; 2575 } 2576 2577 public String toString() { 2578 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2579 final StringBuilder buffer = new StringBuilder(); 2580 append(null, buffer, strategy); 2581 return buffer.toString(); 2582 } 2583 2584 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2585 strategy.appendStart(locator, this, buffer); 2586 appendFields(locator, buffer, strategy); 2587 strategy.appendEnd(locator, this, buffer); 2588 return buffer; 2589 } 2590 2591 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2592 { 2593 List<Object> theAny; 2594 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2595 strategy.appendField(locator, this, "any", buffer, theAny); 2596 } 2597 return buffer; 2598 } 2599 2600 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2601 int currentHashCode = 1; 2602 { 2603 List<Object> theAny; 2604 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2605 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2606 } 2607 return currentHashCode; 2608 } 2609 2610 public int hashCode() { 2611 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2612 return this.hashCode(null, strategy); 2613 } 2614 2615 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2616 if (!(object instanceof DtoMulticastNetworkConnector.BridgeFactory)) { 2617 return false; 2618 } 2619 if (this == object) { 2620 return true; 2621 } 2622 final DtoMulticastNetworkConnector.BridgeFactory that = ((DtoMulticastNetworkConnector.BridgeFactory) object); 2623 { 2624 List<Object> lhsAny; 2625 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2626 List<Object> rhsAny; 2627 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 2628 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2629 return false; 2630 } 2631 } 2632 return true; 2633 } 2634 2635 public boolean equals(Object object) { 2636 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2637 return equals(null, null, object, strategy); 2638 } 2639 2640 } 2641 2642 2643 /** 2644 * <p>Java class for anonymous complex type. 2645 * 2646 * <p>The following schema fragment specifies the expected content contained within this class. 2647 * 2648 * <pre> 2649 * <complexType> 2650 * <complexContent> 2651 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2652 * <choice minOccurs="0"> 2653 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 2654 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 2655 * <any namespace='##other'/> 2656 * </choice> 2657 * </restriction> 2658 * </complexContent> 2659 * </complexType> 2660 * </pre> 2661 * 2662 * 2663 */ 2664 @XmlAccessorType(XmlAccessType.FIELD) 2665 @XmlType(name = "", propOrder = { 2666 "broker", 2667 "brokerService", 2668 "any" 2669 }) 2670 public static class BrokerService 2671 implements Equals, HashCode, ToString 2672 { 2673 2674 protected DtoBroker broker; 2675 protected DtoBrokerService brokerService; 2676 @XmlAnyElement(lax = true) 2677 protected Object any; 2678 2679 /** 2680 * Gets the value of the broker property. 2681 * 2682 * @return 2683 * possible object is 2684 * {@link DtoBroker } 2685 * 2686 */ 2687 public DtoBroker getBroker() { 2688 return broker; 2689 } 2690 2691 /** 2692 * Sets the value of the broker property. 2693 * 2694 * @param value 2695 * allowed object is 2696 * {@link DtoBroker } 2697 * 2698 */ 2699 public void setBroker(DtoBroker value) { 2700 this.broker = value; 2701 } 2702 2703 /** 2704 * Gets the value of the brokerService property. 2705 * 2706 * @return 2707 * possible object is 2708 * {@link DtoBrokerService } 2709 * 2710 */ 2711 public DtoBrokerService getBrokerService() { 2712 return brokerService; 2713 } 2714 2715 /** 2716 * Sets the value of the brokerService property. 2717 * 2718 * @param value 2719 * allowed object is 2720 * {@link DtoBrokerService } 2721 * 2722 */ 2723 public void setBrokerService(DtoBrokerService value) { 2724 this.brokerService = value; 2725 } 2726 2727 /** 2728 * Gets the value of the any property. 2729 * 2730 * @return 2731 * possible object is 2732 * {@link Object } 2733 * 2734 */ 2735 public Object getAny() { 2736 return any; 2737 } 2738 2739 /** 2740 * Sets the value of the any property. 2741 * 2742 * @param value 2743 * allowed object is 2744 * {@link Object } 2745 * 2746 */ 2747 public void setAny(Object value) { 2748 this.any = value; 2749 } 2750 2751 public String toString() { 2752 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2753 final StringBuilder buffer = new StringBuilder(); 2754 append(null, buffer, strategy); 2755 return buffer.toString(); 2756 } 2757 2758 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2759 strategy.appendStart(locator, this, buffer); 2760 appendFields(locator, buffer, strategy); 2761 strategy.appendEnd(locator, this, buffer); 2762 return buffer; 2763 } 2764 2765 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2766 { 2767 DtoBroker theBroker; 2768 theBroker = this.getBroker(); 2769 strategy.appendField(locator, this, "broker", buffer, theBroker); 2770 } 2771 { 2772 DtoBrokerService theBrokerService; 2773 theBrokerService = this.getBrokerService(); 2774 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 2775 } 2776 { 2777 Object theAny; 2778 theAny = this.getAny(); 2779 strategy.appendField(locator, this, "any", buffer, theAny); 2780 } 2781 return buffer; 2782 } 2783 2784 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2785 int currentHashCode = 1; 2786 { 2787 DtoBroker theBroker; 2788 theBroker = this.getBroker(); 2789 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "broker", theBroker), currentHashCode, theBroker); 2790 } 2791 { 2792 DtoBrokerService theBrokerService; 2793 theBrokerService = this.getBrokerService(); 2794 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 2795 } 2796 { 2797 Object theAny; 2798 theAny = this.getAny(); 2799 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2800 } 2801 return currentHashCode; 2802 } 2803 2804 public int hashCode() { 2805 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2806 return this.hashCode(null, strategy); 2807 } 2808 2809 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2810 if (!(object instanceof DtoMulticastNetworkConnector.BrokerService)) { 2811 return false; 2812 } 2813 if (this == object) { 2814 return true; 2815 } 2816 final DtoMulticastNetworkConnector.BrokerService that = ((DtoMulticastNetworkConnector.BrokerService) object); 2817 { 2818 DtoBroker lhsBroker; 2819 lhsBroker = this.getBroker(); 2820 DtoBroker rhsBroker; 2821 rhsBroker = that.getBroker(); 2822 if (!strategy.equals(LocatorUtils.property(thisLocator, "broker", lhsBroker), LocatorUtils.property(thatLocator, "broker", rhsBroker), lhsBroker, rhsBroker)) { 2823 return false; 2824 } 2825 } 2826 { 2827 DtoBrokerService lhsBrokerService; 2828 lhsBrokerService = this.getBrokerService(); 2829 DtoBrokerService rhsBrokerService; 2830 rhsBrokerService = that.getBrokerService(); 2831 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 2832 return false; 2833 } 2834 } 2835 { 2836 Object lhsAny; 2837 lhsAny = this.getAny(); 2838 Object rhsAny; 2839 rhsAny = that.getAny(); 2840 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2841 return false; 2842 } 2843 } 2844 return true; 2845 } 2846 2847 public boolean equals(Object object) { 2848 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2849 return equals(null, null, object, strategy); 2850 } 2851 2852 } 2853 2854 2855 /** 2856 * <p>Java class for anonymous complex type. 2857 * 2858 * <p>The following schema fragment specifies the expected content contained within this class. 2859 * 2860 * <pre> 2861 * <complexType> 2862 * <complexContent> 2863 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2864 * <sequence minOccurs="0"> 2865 * <any maxOccurs="unbounded" minOccurs="0"/> 2866 * </sequence> 2867 * </restriction> 2868 * </complexContent> 2869 * </complexType> 2870 * </pre> 2871 * 2872 * 2873 */ 2874 @XmlAccessorType(XmlAccessType.FIELD) 2875 @XmlType(name = "", propOrder = { 2876 "any" 2877 }) 2878 public static class ConnectionFilter 2879 implements Equals, HashCode, ToString 2880 { 2881 2882 @XmlAnyElement(lax = true) 2883 protected List<Object> any; 2884 2885 /** 2886 * Gets the value of the any property. 2887 * 2888 * <p> 2889 * This accessor method returns a reference to the live list, 2890 * not a snapshot. Therefore any modification you make to the 2891 * returned list will be present inside the JAXB object. 2892 * This is why there is not a <CODE>set</CODE> method for the any property. 2893 * 2894 * <p> 2895 * For example, to add a new item, do as follows: 2896 * <pre> 2897 * getAny().add(newItem); 2898 * </pre> 2899 * 2900 * 2901 * <p> 2902 * Objects of the following type(s) are allowed in the list 2903 * {@link Object } 2904 * 2905 * 2906 */ 2907 public List<Object> getAny() { 2908 if (any == null) { 2909 any = new ArrayList<Object>(); 2910 } 2911 return this.any; 2912 } 2913 2914 public String toString() { 2915 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2916 final StringBuilder buffer = new StringBuilder(); 2917 append(null, buffer, strategy); 2918 return buffer.toString(); 2919 } 2920 2921 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2922 strategy.appendStart(locator, this, buffer); 2923 appendFields(locator, buffer, strategy); 2924 strategy.appendEnd(locator, this, buffer); 2925 return buffer; 2926 } 2927 2928 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2929 { 2930 List<Object> theAny; 2931 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2932 strategy.appendField(locator, this, "any", buffer, theAny); 2933 } 2934 return buffer; 2935 } 2936 2937 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2938 int currentHashCode = 1; 2939 { 2940 List<Object> theAny; 2941 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2942 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2943 } 2944 return currentHashCode; 2945 } 2946 2947 public int hashCode() { 2948 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2949 return this.hashCode(null, strategy); 2950 } 2951 2952 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2953 if (!(object instanceof DtoMulticastNetworkConnector.ConnectionFilter)) { 2954 return false; 2955 } 2956 if (this == object) { 2957 return true; 2958 } 2959 final DtoMulticastNetworkConnector.ConnectionFilter that = ((DtoMulticastNetworkConnector.ConnectionFilter) object); 2960 { 2961 List<Object> lhsAny; 2962 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2963 List<Object> rhsAny; 2964 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 2965 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2966 return false; 2967 } 2968 } 2969 return true; 2970 } 2971 2972 public boolean equals(Object object) { 2973 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2974 return equals(null, null, object, strategy); 2975 } 2976 2977 } 2978 2979 2980 /** 2981 * <p>Java class for anonymous complex type. 2982 * 2983 * <p>The following schema fragment specifies the expected content contained within this class. 2984 * 2985 * <pre> 2986 * <complexType> 2987 * <complexContent> 2988 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2989 * <sequence maxOccurs="unbounded" minOccurs="0"> 2990 * <any maxOccurs="unbounded" minOccurs="0"/> 2991 * </sequence> 2992 * </restriction> 2993 * </complexContent> 2994 * </complexType> 2995 * </pre> 2996 * 2997 * 2998 */ 2999 @XmlAccessorType(XmlAccessType.FIELD) 3000 @XmlType(name = "", propOrder = { 3001 "any" 3002 }) 3003 public static class DurableDestinations 3004 implements Equals, HashCode, ToString 3005 { 3006 3007 @XmlAnyElement(lax = true) 3008 protected List<Object> any; 3009 3010 /** 3011 * Gets the value of the any property. 3012 * 3013 * <p> 3014 * This accessor method returns a reference to the live list, 3015 * not a snapshot. Therefore any modification you make to the 3016 * returned list will be present inside the JAXB object. 3017 * This is why there is not a <CODE>set</CODE> method for the any property. 3018 * 3019 * <p> 3020 * For example, to add a new item, do as follows: 3021 * <pre> 3022 * getAny().add(newItem); 3023 * </pre> 3024 * 3025 * 3026 * <p> 3027 * Objects of the following type(s) are allowed in the list 3028 * {@link Object } 3029 * 3030 * 3031 */ 3032 public List<Object> getAny() { 3033 if (any == null) { 3034 any = new ArrayList<Object>(); 3035 } 3036 return this.any; 3037 } 3038 3039 public String toString() { 3040 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3041 final StringBuilder buffer = new StringBuilder(); 3042 append(null, buffer, strategy); 3043 return buffer.toString(); 3044 } 3045 3046 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3047 strategy.appendStart(locator, this, buffer); 3048 appendFields(locator, buffer, strategy); 3049 strategy.appendEnd(locator, this, buffer); 3050 return buffer; 3051 } 3052 3053 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3054 { 3055 List<Object> theAny; 3056 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3057 strategy.appendField(locator, this, "any", buffer, theAny); 3058 } 3059 return buffer; 3060 } 3061 3062 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3063 int currentHashCode = 1; 3064 { 3065 List<Object> theAny; 3066 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3067 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3068 } 3069 return currentHashCode; 3070 } 3071 3072 public int hashCode() { 3073 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3074 return this.hashCode(null, strategy); 3075 } 3076 3077 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3078 if (!(object instanceof DtoMulticastNetworkConnector.DurableDestinations)) { 3079 return false; 3080 } 3081 if (this == object) { 3082 return true; 3083 } 3084 final DtoMulticastNetworkConnector.DurableDestinations that = ((DtoMulticastNetworkConnector.DurableDestinations) object); 3085 { 3086 List<Object> lhsAny; 3087 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3088 List<Object> rhsAny; 3089 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3090 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3091 return false; 3092 } 3093 } 3094 return true; 3095 } 3096 3097 public boolean equals(Object object) { 3098 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3099 return equals(null, null, object, strategy); 3100 } 3101 3102 } 3103 3104 3105 /** 3106 * <p>Java class for anonymous complex type. 3107 * 3108 * <p>The following schema fragment specifies the expected content contained within this class. 3109 * 3110 * <pre> 3111 * <complexType> 3112 * <complexContent> 3113 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3114 * <sequence maxOccurs="unbounded" minOccurs="0"> 3115 * <any maxOccurs="unbounded" minOccurs="0"/> 3116 * </sequence> 3117 * </restriction> 3118 * </complexContent> 3119 * </complexType> 3120 * </pre> 3121 * 3122 * 3123 */ 3124 @XmlAccessorType(XmlAccessType.FIELD) 3125 @XmlType(name = "", propOrder = { 3126 "any" 3127 }) 3128 public static class DynamicallyIncludedDestinations 3129 implements Equals, HashCode, ToString 3130 { 3131 3132 @XmlAnyElement(lax = true) 3133 protected List<Object> any; 3134 3135 /** 3136 * Gets the value of the any property. 3137 * 3138 * <p> 3139 * This accessor method returns a reference to the live list, 3140 * not a snapshot. Therefore any modification you make to the 3141 * returned list will be present inside the JAXB object. 3142 * This is why there is not a <CODE>set</CODE> method for the any property. 3143 * 3144 * <p> 3145 * For example, to add a new item, do as follows: 3146 * <pre> 3147 * getAny().add(newItem); 3148 * </pre> 3149 * 3150 * 3151 * <p> 3152 * Objects of the following type(s) are allowed in the list 3153 * {@link Object } 3154 * 3155 * 3156 */ 3157 public List<Object> getAny() { 3158 if (any == null) { 3159 any = new ArrayList<Object>(); 3160 } 3161 return this.any; 3162 } 3163 3164 public String toString() { 3165 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3166 final StringBuilder buffer = new StringBuilder(); 3167 append(null, buffer, strategy); 3168 return buffer.toString(); 3169 } 3170 3171 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3172 strategy.appendStart(locator, this, buffer); 3173 appendFields(locator, buffer, strategy); 3174 strategy.appendEnd(locator, this, buffer); 3175 return buffer; 3176 } 3177 3178 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3179 { 3180 List<Object> theAny; 3181 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3182 strategy.appendField(locator, this, "any", buffer, theAny); 3183 } 3184 return buffer; 3185 } 3186 3187 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3188 int currentHashCode = 1; 3189 { 3190 List<Object> theAny; 3191 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3192 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3193 } 3194 return currentHashCode; 3195 } 3196 3197 public int hashCode() { 3198 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3199 return this.hashCode(null, strategy); 3200 } 3201 3202 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3203 if (!(object instanceof DtoMulticastNetworkConnector.DynamicallyIncludedDestinations)) { 3204 return false; 3205 } 3206 if (this == object) { 3207 return true; 3208 } 3209 final DtoMulticastNetworkConnector.DynamicallyIncludedDestinations that = ((DtoMulticastNetworkConnector.DynamicallyIncludedDestinations) object); 3210 { 3211 List<Object> lhsAny; 3212 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3213 List<Object> rhsAny; 3214 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3215 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3216 return false; 3217 } 3218 } 3219 return true; 3220 } 3221 3222 public boolean equals(Object object) { 3223 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3224 return equals(null, null, object, strategy); 3225 } 3226 3227 } 3228 3229 3230 /** 3231 * <p>Java class for anonymous complex type. 3232 * 3233 * <p>The following schema fragment specifies the expected content contained within this class. 3234 * 3235 * <pre> 3236 * <complexType> 3237 * <complexContent> 3238 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3239 * <sequence maxOccurs="unbounded" minOccurs="0"> 3240 * <any maxOccurs="unbounded" minOccurs="0"/> 3241 * </sequence> 3242 * </restriction> 3243 * </complexContent> 3244 * </complexType> 3245 * </pre> 3246 * 3247 * 3248 */ 3249 @XmlAccessorType(XmlAccessType.FIELD) 3250 @XmlType(name = "", propOrder = { 3251 "any" 3252 }) 3253 public static class ExcludedDestinations 3254 implements Equals, HashCode, ToString 3255 { 3256 3257 @XmlAnyElement(lax = true) 3258 protected List<Object> any; 3259 3260 /** 3261 * Gets the value of the any property. 3262 * 3263 * <p> 3264 * This accessor method returns a reference to the live list, 3265 * not a snapshot. Therefore any modification you make to the 3266 * returned list will be present inside the JAXB object. 3267 * This is why there is not a <CODE>set</CODE> method for the any property. 3268 * 3269 * <p> 3270 * For example, to add a new item, do as follows: 3271 * <pre> 3272 * getAny().add(newItem); 3273 * </pre> 3274 * 3275 * 3276 * <p> 3277 * Objects of the following type(s) are allowed in the list 3278 * {@link Object } 3279 * 3280 * 3281 */ 3282 public List<Object> getAny() { 3283 if (any == null) { 3284 any = new ArrayList<Object>(); 3285 } 3286 return this.any; 3287 } 3288 3289 public String toString() { 3290 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3291 final StringBuilder buffer = new StringBuilder(); 3292 append(null, buffer, strategy); 3293 return buffer.toString(); 3294 } 3295 3296 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3297 strategy.appendStart(locator, this, buffer); 3298 appendFields(locator, buffer, strategy); 3299 strategy.appendEnd(locator, this, buffer); 3300 return buffer; 3301 } 3302 3303 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3304 { 3305 List<Object> theAny; 3306 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3307 strategy.appendField(locator, this, "any", buffer, theAny); 3308 } 3309 return buffer; 3310 } 3311 3312 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3313 int currentHashCode = 1; 3314 { 3315 List<Object> theAny; 3316 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3317 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3318 } 3319 return currentHashCode; 3320 } 3321 3322 public int hashCode() { 3323 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3324 return this.hashCode(null, strategy); 3325 } 3326 3327 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3328 if (!(object instanceof DtoMulticastNetworkConnector.ExcludedDestinations)) { 3329 return false; 3330 } 3331 if (this == object) { 3332 return true; 3333 } 3334 final DtoMulticastNetworkConnector.ExcludedDestinations that = ((DtoMulticastNetworkConnector.ExcludedDestinations) object); 3335 { 3336 List<Object> lhsAny; 3337 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3338 List<Object> rhsAny; 3339 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3340 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3341 return false; 3342 } 3343 } 3344 return true; 3345 } 3346 3347 public boolean equals(Object object) { 3348 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3349 return equals(null, null, object, strategy); 3350 } 3351 3352 } 3353 3354 3355 /** 3356 * <p>Java class for anonymous complex type. 3357 * 3358 * <p>The following schema fragment specifies the expected content contained within this class. 3359 * 3360 * <pre> 3361 * <complexType> 3362 * <complexContent> 3363 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3364 * <sequence minOccurs="0"> 3365 * <any maxOccurs="unbounded" minOccurs="0"/> 3366 * </sequence> 3367 * </restriction> 3368 * </complexContent> 3369 * </complexType> 3370 * </pre> 3371 * 3372 * 3373 */ 3374 @XmlAccessorType(XmlAccessType.FIELD) 3375 @XmlType(name = "", propOrder = { 3376 "any" 3377 }) 3378 public static class LocalTransport 3379 implements Equals, HashCode, ToString 3380 { 3381 3382 @XmlAnyElement(lax = true) 3383 protected List<Object> any; 3384 3385 /** 3386 * Gets the value of the any property. 3387 * 3388 * <p> 3389 * This accessor method returns a reference to the live list, 3390 * not a snapshot. Therefore any modification you make to the 3391 * returned list will be present inside the JAXB object. 3392 * This is why there is not a <CODE>set</CODE> method for the any property. 3393 * 3394 * <p> 3395 * For example, to add a new item, do as follows: 3396 * <pre> 3397 * getAny().add(newItem); 3398 * </pre> 3399 * 3400 * 3401 * <p> 3402 * Objects of the following type(s) are allowed in the list 3403 * {@link Object } 3404 * 3405 * 3406 */ 3407 public List<Object> getAny() { 3408 if (any == null) { 3409 any = new ArrayList<Object>(); 3410 } 3411 return this.any; 3412 } 3413 3414 public String toString() { 3415 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3416 final StringBuilder buffer = new StringBuilder(); 3417 append(null, buffer, strategy); 3418 return buffer.toString(); 3419 } 3420 3421 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3422 strategy.appendStart(locator, this, buffer); 3423 appendFields(locator, buffer, strategy); 3424 strategy.appendEnd(locator, this, buffer); 3425 return buffer; 3426 } 3427 3428 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3429 { 3430 List<Object> theAny; 3431 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3432 strategy.appendField(locator, this, "any", buffer, theAny); 3433 } 3434 return buffer; 3435 } 3436 3437 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3438 int currentHashCode = 1; 3439 { 3440 List<Object> theAny; 3441 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3442 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3443 } 3444 return currentHashCode; 3445 } 3446 3447 public int hashCode() { 3448 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3449 return this.hashCode(null, strategy); 3450 } 3451 3452 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3453 if (!(object instanceof DtoMulticastNetworkConnector.LocalTransport)) { 3454 return false; 3455 } 3456 if (this == object) { 3457 return true; 3458 } 3459 final DtoMulticastNetworkConnector.LocalTransport that = ((DtoMulticastNetworkConnector.LocalTransport) object); 3460 { 3461 List<Object> lhsAny; 3462 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3463 List<Object> rhsAny; 3464 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3465 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3466 return false; 3467 } 3468 } 3469 return true; 3470 } 3471 3472 public boolean equals(Object object) { 3473 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3474 return equals(null, null, object, strategy); 3475 } 3476 3477 } 3478 3479 3480 /** 3481 * <p>Java class for anonymous complex type. 3482 * 3483 * <p>The following schema fragment specifies the expected content contained within this class. 3484 * 3485 * <pre> 3486 * <complexType> 3487 * <complexContent> 3488 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3489 * <sequence minOccurs="0"> 3490 * <any maxOccurs="unbounded" minOccurs="0"/> 3491 * </sequence> 3492 * </restriction> 3493 * </complexContent> 3494 * </complexType> 3495 * </pre> 3496 * 3497 * 3498 */ 3499 @XmlAccessorType(XmlAccessType.FIELD) 3500 @XmlType(name = "", propOrder = { 3501 "any" 3502 }) 3503 public static class RemoteTransport 3504 implements Equals, HashCode, ToString 3505 { 3506 3507 @XmlAnyElement(lax = true) 3508 protected List<Object> any; 3509 3510 /** 3511 * Gets the value of the any property. 3512 * 3513 * <p> 3514 * This accessor method returns a reference to the live list, 3515 * not a snapshot. Therefore any modification you make to the 3516 * returned list will be present inside the JAXB object. 3517 * This is why there is not a <CODE>set</CODE> method for the any property. 3518 * 3519 * <p> 3520 * For example, to add a new item, do as follows: 3521 * <pre> 3522 * getAny().add(newItem); 3523 * </pre> 3524 * 3525 * 3526 * <p> 3527 * Objects of the following type(s) are allowed in the list 3528 * {@link Object } 3529 * 3530 * 3531 */ 3532 public List<Object> getAny() { 3533 if (any == null) { 3534 any = new ArrayList<Object>(); 3535 } 3536 return this.any; 3537 } 3538 3539 public String toString() { 3540 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3541 final StringBuilder buffer = new StringBuilder(); 3542 append(null, buffer, strategy); 3543 return buffer.toString(); 3544 } 3545 3546 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3547 strategy.appendStart(locator, this, buffer); 3548 appendFields(locator, buffer, strategy); 3549 strategy.appendEnd(locator, this, buffer); 3550 return buffer; 3551 } 3552 3553 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3554 { 3555 List<Object> theAny; 3556 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3557 strategy.appendField(locator, this, "any", buffer, theAny); 3558 } 3559 return buffer; 3560 } 3561 3562 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3563 int currentHashCode = 1; 3564 { 3565 List<Object> theAny; 3566 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3567 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3568 } 3569 return currentHashCode; 3570 } 3571 3572 public int hashCode() { 3573 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3574 return this.hashCode(null, strategy); 3575 } 3576 3577 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3578 if (!(object instanceof DtoMulticastNetworkConnector.RemoteTransport)) { 3579 return false; 3580 } 3581 if (this == object) { 3582 return true; 3583 } 3584 final DtoMulticastNetworkConnector.RemoteTransport that = ((DtoMulticastNetworkConnector.RemoteTransport) object); 3585 { 3586 List<Object> lhsAny; 3587 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3588 List<Object> rhsAny; 3589 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3590 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3591 return false; 3592 } 3593 } 3594 return true; 3595 } 3596 3597 public boolean equals(Object object) { 3598 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3599 return equals(null, null, object, strategy); 3600 } 3601 3602 } 3603 3604 3605 /** 3606 * <p>Java class for anonymous complex type. 3607 * 3608 * <p>The following schema fragment specifies the expected content contained within this class. 3609 * 3610 * <pre> 3611 * <complexType> 3612 * <complexContent> 3613 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3614 * <sequence maxOccurs="unbounded" minOccurs="0"> 3615 * <any maxOccurs="unbounded" minOccurs="0"/> 3616 * </sequence> 3617 * </restriction> 3618 * </complexContent> 3619 * </complexType> 3620 * </pre> 3621 * 3622 * 3623 */ 3624 @XmlAccessorType(XmlAccessType.FIELD) 3625 @XmlType(name = "", propOrder = { 3626 "any" 3627 }) 3628 public static class StaticallyIncludedDestinations 3629 implements Equals, HashCode, ToString 3630 { 3631 3632 @XmlAnyElement(lax = true) 3633 protected List<Object> any; 3634 3635 /** 3636 * Gets the value of the any property. 3637 * 3638 * <p> 3639 * This accessor method returns a reference to the live list, 3640 * not a snapshot. Therefore any modification you make to the 3641 * returned list will be present inside the JAXB object. 3642 * This is why there is not a <CODE>set</CODE> method for the any property. 3643 * 3644 * <p> 3645 * For example, to add a new item, do as follows: 3646 * <pre> 3647 * getAny().add(newItem); 3648 * </pre> 3649 * 3650 * 3651 * <p> 3652 * Objects of the following type(s) are allowed in the list 3653 * {@link Object } 3654 * 3655 * 3656 */ 3657 public List<Object> getAny() { 3658 if (any == null) { 3659 any = new ArrayList<Object>(); 3660 } 3661 return this.any; 3662 } 3663 3664 public String toString() { 3665 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3666 final StringBuilder buffer = new StringBuilder(); 3667 append(null, buffer, strategy); 3668 return buffer.toString(); 3669 } 3670 3671 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3672 strategy.appendStart(locator, this, buffer); 3673 appendFields(locator, buffer, strategy); 3674 strategy.appendEnd(locator, this, buffer); 3675 return buffer; 3676 } 3677 3678 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3679 { 3680 List<Object> theAny; 3681 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3682 strategy.appendField(locator, this, "any", buffer, theAny); 3683 } 3684 return buffer; 3685 } 3686 3687 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3688 int currentHashCode = 1; 3689 { 3690 List<Object> theAny; 3691 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3692 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3693 } 3694 return currentHashCode; 3695 } 3696 3697 public int hashCode() { 3698 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3699 return this.hashCode(null, strategy); 3700 } 3701 3702 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3703 if (!(object instanceof DtoMulticastNetworkConnector.StaticallyIncludedDestinations)) { 3704 return false; 3705 } 3706 if (this == object) { 3707 return true; 3708 } 3709 final DtoMulticastNetworkConnector.StaticallyIncludedDestinations that = ((DtoMulticastNetworkConnector.StaticallyIncludedDestinations) object); 3710 { 3711 List<Object> lhsAny; 3712 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3713 List<Object> rhsAny; 3714 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3715 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3716 return false; 3717 } 3718 } 3719 return true; 3720 } 3721 3722 public boolean equals(Object object) { 3723 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3724 return equals(null, null, object, strategy); 3725 } 3726 3727 } 3728 3729}