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