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