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