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