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