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