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