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