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