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