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