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