001// 002// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.10-b140310.1920 003// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 004// Any modifications to this file will be lost upon recompilation of the source schema. 005// Generated on: 2019.03.15 at 09:00:08 AM EDT 006// 007 008 009package org.apache.activemq.schema.core; 010 011import java.util.ArrayList; 012import java.util.HashMap; 013import java.util.List; 014import java.util.Map; 015import javax.xml.bind.JAXBElement; 016import javax.xml.bind.annotation.XmlAccessType; 017import javax.xml.bind.annotation.XmlAccessorType; 018import javax.xml.bind.annotation.XmlAnyAttribute; 019import javax.xml.bind.annotation.XmlAnyElement; 020import javax.xml.bind.annotation.XmlAttribute; 021import javax.xml.bind.annotation.XmlElementRef; 022import javax.xml.bind.annotation.XmlElementRefs; 023import javax.xml.bind.annotation.XmlID; 024import javax.xml.bind.annotation.XmlRootElement; 025import javax.xml.bind.annotation.XmlSchemaType; 026import javax.xml.bind.annotation.XmlType; 027import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; 028import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 029import javax.xml.namespace.QName; 030import org.jvnet.jaxb2_commons.lang.Equals; 031import org.jvnet.jaxb2_commons.lang.EqualsStrategy; 032import org.jvnet.jaxb2_commons.lang.HashCode; 033import org.jvnet.jaxb2_commons.lang.HashCodeStrategy; 034import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy; 035import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; 036import org.jvnet.jaxb2_commons.lang.ToString; 037import org.jvnet.jaxb2_commons.lang.ToStringStrategy; 038import org.jvnet.jaxb2_commons.locator.ObjectLocator; 039import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; 040 041 042/** 043 * <p>Java class for anonymous complex type. 044 * 045 * <p>The following schema fragment specifies the expected content contained within this class. 046 * 047 * <pre> 048 * <complexType> 049 * <complexContent> 050 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 051 * <choice maxOccurs="unbounded" minOccurs="0"> 052 * <choice> 053 * <element name="consumer" minOccurs="0"> 054 * <complexType> 055 * <complexContent> 056 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 057 * <sequence minOccurs="0"> 058 * <any maxOccurs="unbounded" minOccurs="0"/> 059 * </sequence> 060 * </restriction> 061 * </complexContent> 062 * </complexType> 063 * </element> 064 * <element name="consumerConnection" minOccurs="0"> 065 * <complexType> 066 * <complexContent> 067 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 068 * <sequence minOccurs="0"> 069 * <any maxOccurs="unbounded" minOccurs="0"/> 070 * </sequence> 071 * </restriction> 072 * </complexContent> 073 * </complexType> 074 * </element> 075 * <element name="consumerQueue" minOccurs="0"> 076 * <complexType> 077 * <complexContent> 078 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 079 * <choice minOccurs="0"> 080 * <element ref="{http://activemq.apache.org/schema/core}queue"/> 081 * <any namespace='##other'/> 082 * </choice> 083 * </restriction> 084 * </complexContent> 085 * </complexType> 086 * </element> 087 * <element name="jmsConnector" minOccurs="0"> 088 * <complexType> 089 * <complexContent> 090 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 091 * <choice minOccurs="0"> 092 * <element ref="{http://activemq.apache.org/schema/core}jmsQueueConnector"/> 093 * <element ref="{http://activemq.apache.org/schema/core}jmsTopicConnector"/> 094 * <any namespace='##other'/> 095 * </choice> 096 * </restriction> 097 * </complexContent> 098 * </complexType> 099 * </element> 100 * <element name="jmsMessageConvertor" minOccurs="0"> 101 * <complexType> 102 * <complexContent> 103 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 104 * <choice minOccurs="0"> 105 * <element ref="{http://activemq.apache.org/schema/core}simpleJmsMessageConvertor"/> 106 * <any namespace='##other'/> 107 * </choice> 108 * </restriction> 109 * </complexContent> 110 * </complexType> 111 * </element> 112 * <element name="producerConnection" minOccurs="0"> 113 * <complexType> 114 * <complexContent> 115 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 116 * <sequence minOccurs="0"> 117 * <any maxOccurs="unbounded" minOccurs="0"/> 118 * </sequence> 119 * </restriction> 120 * </complexContent> 121 * </complexType> 122 * </element> 123 * <element name="producerQueue" minOccurs="0"> 124 * <complexType> 125 * <complexContent> 126 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 127 * <choice minOccurs="0"> 128 * <element ref="{http://activemq.apache.org/schema/core}queue"/> 129 * <any namespace='##other'/> 130 * </choice> 131 * </restriction> 132 * </complexContent> 133 * </complexType> 134 * </element> 135 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 136 * </choice> 137 * </choice> 138 * <attribute name="consumer" type="{http://www.w3.org/2001/XMLSchema}string" /> 139 * <attribute name="consumerConnection" type="{http://www.w3.org/2001/XMLSchema}string" /> 140 * <attribute name="consumerQueue" type="{http://www.w3.org/2001/XMLSchema}string" /> 141 * <attribute name="doHandleReplyTo" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 142 * <attribute name="jmsConnector" type="{http://www.w3.org/2001/XMLSchema}string" /> 143 * <attribute name="jmsMessageConvertor" type="{http://www.w3.org/2001/XMLSchema}string" /> 144 * <attribute name="localQueueName" type="{http://www.w3.org/2001/XMLSchema}string" /> 145 * <attribute name="outboundQueueName" type="{http://www.w3.org/2001/XMLSchema}string" /> 146 * <attribute name="producerConnection" type="{http://www.w3.org/2001/XMLSchema}string" /> 147 * <attribute name="producerQueue" type="{http://www.w3.org/2001/XMLSchema}string" /> 148 * <attribute name="selector" type="{http://www.w3.org/2001/XMLSchema}string" /> 149 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 150 * <anyAttribute processContents='lax' namespace='##other'/> 151 * </restriction> 152 * </complexContent> 153 * </complexType> 154 * </pre> 155 * 156 * 157 */ 158@XmlAccessorType(XmlAccessType.FIELD) 159@XmlType(name = "", propOrder = { 160 "consumerOrConsumerConnectionOrConsumerQueue" 161}) 162@XmlRootElement(name = "outboundQueueBridge") 163public class DtoOutboundQueueBridge implements Equals, HashCode, ToString 164{ 165 166 @XmlElementRefs({ 167 @XmlElementRef(name = "consumerQueue", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 168 @XmlElementRef(name = "consumer", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 169 @XmlElementRef(name = "producerQueue", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 170 @XmlElementRef(name = "consumerConnection", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 171 @XmlElementRef(name = "jmsConnector", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 172 @XmlElementRef(name = "jmsMessageConvertor", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 173 @XmlElementRef(name = "producerConnection", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 174 }) 175 @XmlAnyElement(lax = true) 176 protected List<Object> consumerOrConsumerConnectionOrConsumerQueue; 177 @XmlAttribute(name = "consumer") 178 protected String consumer; 179 @XmlAttribute(name = "consumerConnection") 180 protected String consumerConnection; 181 @XmlAttribute(name = "consumerQueue") 182 protected String consumerQueue; 183 @XmlAttribute(name = "doHandleReplyTo") 184 protected Boolean doHandleReplyTo; 185 @XmlAttribute(name = "jmsConnector") 186 protected String jmsConnector; 187 @XmlAttribute(name = "jmsMessageConvertor") 188 protected String jmsMessageConvertor; 189 @XmlAttribute(name = "localQueueName") 190 protected String localQueueName; 191 @XmlAttribute(name = "outboundQueueName") 192 protected String outboundQueueName; 193 @XmlAttribute(name = "producerConnection") 194 protected String producerConnection; 195 @XmlAttribute(name = "producerQueue") 196 protected String producerQueue; 197 @XmlAttribute(name = "selector") 198 protected String selector; 199 @XmlAttribute(name = "id") 200 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 201 @XmlID 202 @XmlSchemaType(name = "ID") 203 protected String id; 204 @XmlAnyAttribute 205 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 206 207 /** 208 * Gets the value of the consumerOrConsumerConnectionOrConsumerQueue property. 209 * 210 * <p> 211 * This accessor method returns a reference to the live list, 212 * not a snapshot. Therefore any modification you make to the 213 * returned list will be present inside the JAXB object. 214 * This is why there is not a <CODE>set</CODE> method for the consumerOrConsumerConnectionOrConsumerQueue property. 215 * 216 * <p> 217 * For example, to add a new item, do as follows: 218 * <pre> 219 * getConsumerOrConsumerConnectionOrConsumerQueue().add(newItem); 220 * </pre> 221 * 222 * 223 * <p> 224 * Objects of the following type(s) are allowed in the list 225 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.ConsumerQueue }{@code >} 226 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.Consumer }{@code >} 227 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.ProducerQueue }{@code >} 228 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.ConsumerConnection }{@code >} 229 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.JmsConnector }{@code >} 230 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.JmsMessageConvertor }{@code >} 231 * {@link Object } 232 * {@link JAXBElement }{@code <}{@link DtoOutboundQueueBridge.ProducerConnection }{@code >} 233 * 234 * 235 */ 236 public List<Object> getConsumerOrConsumerConnectionOrConsumerQueue() { 237 if (consumerOrConsumerConnectionOrConsumerQueue == null) { 238 consumerOrConsumerConnectionOrConsumerQueue = new ArrayList<Object>(); 239 } 240 return this.consumerOrConsumerConnectionOrConsumerQueue; 241 } 242 243 /** 244 * Gets the value of the consumer property. 245 * 246 * @return 247 * possible object is 248 * {@link String } 249 * 250 */ 251 public String getConsumer() { 252 return consumer; 253 } 254 255 /** 256 * Sets the value of the consumer property. 257 * 258 * @param value 259 * allowed object is 260 * {@link String } 261 * 262 */ 263 public void setConsumer(String value) { 264 this.consumer = value; 265 } 266 267 /** 268 * Gets the value of the consumerConnection property. 269 * 270 * @return 271 * possible object is 272 * {@link String } 273 * 274 */ 275 public String getConsumerConnection() { 276 return consumerConnection; 277 } 278 279 /** 280 * Sets the value of the consumerConnection property. 281 * 282 * @param value 283 * allowed object is 284 * {@link String } 285 * 286 */ 287 public void setConsumerConnection(String value) { 288 this.consumerConnection = value; 289 } 290 291 /** 292 * Gets the value of the consumerQueue property. 293 * 294 * @return 295 * possible object is 296 * {@link String } 297 * 298 */ 299 public String getConsumerQueue() { 300 return consumerQueue; 301 } 302 303 /** 304 * Sets the value of the consumerQueue property. 305 * 306 * @param value 307 * allowed object is 308 * {@link String } 309 * 310 */ 311 public void setConsumerQueue(String value) { 312 this.consumerQueue = value; 313 } 314 315 /** 316 * Gets the value of the doHandleReplyTo property. 317 * 318 * @return 319 * possible object is 320 * {@link Boolean } 321 * 322 */ 323 public Boolean isDoHandleReplyTo() { 324 return doHandleReplyTo; 325 } 326 327 /** 328 * Sets the value of the doHandleReplyTo property. 329 * 330 * @param value 331 * allowed object is 332 * {@link Boolean } 333 * 334 */ 335 public void setDoHandleReplyTo(Boolean value) { 336 this.doHandleReplyTo = value; 337 } 338 339 /** 340 * Gets the value of the jmsConnector property. 341 * 342 * @return 343 * possible object is 344 * {@link String } 345 * 346 */ 347 public String getJmsConnector() { 348 return jmsConnector; 349 } 350 351 /** 352 * Sets the value of the jmsConnector property. 353 * 354 * @param value 355 * allowed object is 356 * {@link String } 357 * 358 */ 359 public void setJmsConnector(String value) { 360 this.jmsConnector = value; 361 } 362 363 /** 364 * Gets the value of the jmsMessageConvertor property. 365 * 366 * @return 367 * possible object is 368 * {@link String } 369 * 370 */ 371 public String getJmsMessageConvertor() { 372 return jmsMessageConvertor; 373 } 374 375 /** 376 * Sets the value of the jmsMessageConvertor property. 377 * 378 * @param value 379 * allowed object is 380 * {@link String } 381 * 382 */ 383 public void setJmsMessageConvertor(String value) { 384 this.jmsMessageConvertor = value; 385 } 386 387 /** 388 * Gets the value of the localQueueName property. 389 * 390 * @return 391 * possible object is 392 * {@link String } 393 * 394 */ 395 public String getLocalQueueName() { 396 return localQueueName; 397 } 398 399 /** 400 * Sets the value of the localQueueName property. 401 * 402 * @param value 403 * allowed object is 404 * {@link String } 405 * 406 */ 407 public void setLocalQueueName(String value) { 408 this.localQueueName = value; 409 } 410 411 /** 412 * Gets the value of the outboundQueueName property. 413 * 414 * @return 415 * possible object is 416 * {@link String } 417 * 418 */ 419 public String getOutboundQueueName() { 420 return outboundQueueName; 421 } 422 423 /** 424 * Sets the value of the outboundQueueName property. 425 * 426 * @param value 427 * allowed object is 428 * {@link String } 429 * 430 */ 431 public void setOutboundQueueName(String value) { 432 this.outboundQueueName = value; 433 } 434 435 /** 436 * Gets the value of the producerConnection property. 437 * 438 * @return 439 * possible object is 440 * {@link String } 441 * 442 */ 443 public String getProducerConnection() { 444 return producerConnection; 445 } 446 447 /** 448 * Sets the value of the producerConnection property. 449 * 450 * @param value 451 * allowed object is 452 * {@link String } 453 * 454 */ 455 public void setProducerConnection(String value) { 456 this.producerConnection = value; 457 } 458 459 /** 460 * Gets the value of the producerQueue property. 461 * 462 * @return 463 * possible object is 464 * {@link String } 465 * 466 */ 467 public String getProducerQueue() { 468 return producerQueue; 469 } 470 471 /** 472 * Sets the value of the producerQueue property. 473 * 474 * @param value 475 * allowed object is 476 * {@link String } 477 * 478 */ 479 public void setProducerQueue(String value) { 480 this.producerQueue = value; 481 } 482 483 /** 484 * Gets the value of the selector property. 485 * 486 * @return 487 * possible object is 488 * {@link String } 489 * 490 */ 491 public String getSelector() { 492 return selector; 493 } 494 495 /** 496 * Sets the value of the selector property. 497 * 498 * @param value 499 * allowed object is 500 * {@link String } 501 * 502 */ 503 public void setSelector(String value) { 504 this.selector = value; 505 } 506 507 /** 508 * Gets the value of the id property. 509 * 510 * @return 511 * possible object is 512 * {@link String } 513 * 514 */ 515 public String getId() { 516 return id; 517 } 518 519 /** 520 * Sets the value of the id property. 521 * 522 * @param value 523 * allowed object is 524 * {@link String } 525 * 526 */ 527 public void setId(String value) { 528 this.id = value; 529 } 530 531 /** 532 * Gets a map that contains attributes that aren't bound to any typed property on this class. 533 * 534 * <p> 535 * the map is keyed by the name of the attribute and 536 * the value is the string value of the attribute. 537 * 538 * the map returned by this method is live, and you can add new attribute 539 * by updating the map directly. Because of this design, there's no setter. 540 * 541 * 542 * @return 543 * always non-null 544 */ 545 public Map<QName, String> getOtherAttributes() { 546 return otherAttributes; 547 } 548 549 public String toString() { 550 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 551 final StringBuilder buffer = new StringBuilder(); 552 append(null, buffer, strategy); 553 return buffer.toString(); 554 } 555 556 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 557 strategy.appendStart(locator, this, buffer); 558 appendFields(locator, buffer, strategy); 559 strategy.appendEnd(locator, this, buffer); 560 return buffer; 561 } 562 563 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 564 { 565 List<Object> theConsumerOrConsumerConnectionOrConsumerQueue; 566 theConsumerOrConsumerConnectionOrConsumerQueue = (((this.consumerOrConsumerConnectionOrConsumerQueue!= null)&&(!this.consumerOrConsumerConnectionOrConsumerQueue.isEmpty()))?this.getConsumerOrConsumerConnectionOrConsumerQueue():null); 567 strategy.appendField(locator, this, "consumerOrConsumerConnectionOrConsumerQueue", buffer, theConsumerOrConsumerConnectionOrConsumerQueue); 568 } 569 { 570 String theConsumer; 571 theConsumer = this.getConsumer(); 572 strategy.appendField(locator, this, "consumer", buffer, theConsumer); 573 } 574 { 575 String theConsumerConnection; 576 theConsumerConnection = this.getConsumerConnection(); 577 strategy.appendField(locator, this, "consumerConnection", buffer, theConsumerConnection); 578 } 579 { 580 String theConsumerQueue; 581 theConsumerQueue = this.getConsumerQueue(); 582 strategy.appendField(locator, this, "consumerQueue", buffer, theConsumerQueue); 583 } 584 { 585 Boolean theDoHandleReplyTo; 586 theDoHandleReplyTo = this.isDoHandleReplyTo(); 587 strategy.appendField(locator, this, "doHandleReplyTo", buffer, theDoHandleReplyTo); 588 } 589 { 590 String theJmsConnector; 591 theJmsConnector = this.getJmsConnector(); 592 strategy.appendField(locator, this, "jmsConnector", buffer, theJmsConnector); 593 } 594 { 595 String theJmsMessageConvertor; 596 theJmsMessageConvertor = this.getJmsMessageConvertor(); 597 strategy.appendField(locator, this, "jmsMessageConvertor", buffer, theJmsMessageConvertor); 598 } 599 { 600 String theLocalQueueName; 601 theLocalQueueName = this.getLocalQueueName(); 602 strategy.appendField(locator, this, "localQueueName", buffer, theLocalQueueName); 603 } 604 { 605 String theOutboundQueueName; 606 theOutboundQueueName = this.getOutboundQueueName(); 607 strategy.appendField(locator, this, "outboundQueueName", buffer, theOutboundQueueName); 608 } 609 { 610 String theProducerConnection; 611 theProducerConnection = this.getProducerConnection(); 612 strategy.appendField(locator, this, "producerConnection", buffer, theProducerConnection); 613 } 614 { 615 String theProducerQueue; 616 theProducerQueue = this.getProducerQueue(); 617 strategy.appendField(locator, this, "producerQueue", buffer, theProducerQueue); 618 } 619 { 620 String theSelector; 621 theSelector = this.getSelector(); 622 strategy.appendField(locator, this, "selector", buffer, theSelector); 623 } 624 { 625 String theId; 626 theId = this.getId(); 627 strategy.appendField(locator, this, "id", buffer, theId); 628 } 629 return buffer; 630 } 631 632 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 633 int currentHashCode = 1; 634 { 635 List<Object> theConsumerOrConsumerConnectionOrConsumerQueue; 636 theConsumerOrConsumerConnectionOrConsumerQueue = (((this.consumerOrConsumerConnectionOrConsumerQueue!= null)&&(!this.consumerOrConsumerConnectionOrConsumerQueue.isEmpty()))?this.getConsumerOrConsumerConnectionOrConsumerQueue():null); 637 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumerOrConsumerConnectionOrConsumerQueue", theConsumerOrConsumerConnectionOrConsumerQueue), currentHashCode, theConsumerOrConsumerConnectionOrConsumerQueue); 638 } 639 { 640 String theConsumer; 641 theConsumer = this.getConsumer(); 642 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumer", theConsumer), currentHashCode, theConsumer); 643 } 644 { 645 String theConsumerConnection; 646 theConsumerConnection = this.getConsumerConnection(); 647 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumerConnection", theConsumerConnection), currentHashCode, theConsumerConnection); 648 } 649 { 650 String theConsumerQueue; 651 theConsumerQueue = this.getConsumerQueue(); 652 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "consumerQueue", theConsumerQueue), currentHashCode, theConsumerQueue); 653 } 654 { 655 Boolean theDoHandleReplyTo; 656 theDoHandleReplyTo = this.isDoHandleReplyTo(); 657 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "doHandleReplyTo", theDoHandleReplyTo), currentHashCode, theDoHandleReplyTo); 658 } 659 { 660 String theJmsConnector; 661 theJmsConnector = this.getJmsConnector(); 662 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "jmsConnector", theJmsConnector), currentHashCode, theJmsConnector); 663 } 664 { 665 String theJmsMessageConvertor; 666 theJmsMessageConvertor = this.getJmsMessageConvertor(); 667 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "jmsMessageConvertor", theJmsMessageConvertor), currentHashCode, theJmsMessageConvertor); 668 } 669 { 670 String theLocalQueueName; 671 theLocalQueueName = this.getLocalQueueName(); 672 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "localQueueName", theLocalQueueName), currentHashCode, theLocalQueueName); 673 } 674 { 675 String theOutboundQueueName; 676 theOutboundQueueName = this.getOutboundQueueName(); 677 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "outboundQueueName", theOutboundQueueName), currentHashCode, theOutboundQueueName); 678 } 679 { 680 String theProducerConnection; 681 theProducerConnection = this.getProducerConnection(); 682 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "producerConnection", theProducerConnection), currentHashCode, theProducerConnection); 683 } 684 { 685 String theProducerQueue; 686 theProducerQueue = this.getProducerQueue(); 687 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "producerQueue", theProducerQueue), currentHashCode, theProducerQueue); 688 } 689 { 690 String theSelector; 691 theSelector = this.getSelector(); 692 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "selector", theSelector), currentHashCode, theSelector); 693 } 694 { 695 String theId; 696 theId = this.getId(); 697 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 698 } 699 return currentHashCode; 700 } 701 702 public int hashCode() { 703 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 704 return this.hashCode(null, strategy); 705 } 706 707 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 708 if (!(object instanceof DtoOutboundQueueBridge)) { 709 return false; 710 } 711 if (this == object) { 712 return true; 713 } 714 final DtoOutboundQueueBridge that = ((DtoOutboundQueueBridge) object); 715 { 716 List<Object> lhsConsumerOrConsumerConnectionOrConsumerQueue; 717 lhsConsumerOrConsumerConnectionOrConsumerQueue = (((this.consumerOrConsumerConnectionOrConsumerQueue!= null)&&(!this.consumerOrConsumerConnectionOrConsumerQueue.isEmpty()))?this.getConsumerOrConsumerConnectionOrConsumerQueue():null); 718 List<Object> rhsConsumerOrConsumerConnectionOrConsumerQueue; 719 rhsConsumerOrConsumerConnectionOrConsumerQueue = (((that.consumerOrConsumerConnectionOrConsumerQueue!= null)&&(!that.consumerOrConsumerConnectionOrConsumerQueue.isEmpty()))?that.getConsumerOrConsumerConnectionOrConsumerQueue():null); 720 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumerOrConsumerConnectionOrConsumerQueue", lhsConsumerOrConsumerConnectionOrConsumerQueue), LocatorUtils.property(thatLocator, "consumerOrConsumerConnectionOrConsumerQueue", rhsConsumerOrConsumerConnectionOrConsumerQueue), lhsConsumerOrConsumerConnectionOrConsumerQueue, rhsConsumerOrConsumerConnectionOrConsumerQueue)) { 721 return false; 722 } 723 } 724 { 725 String lhsConsumer; 726 lhsConsumer = this.getConsumer(); 727 String rhsConsumer; 728 rhsConsumer = that.getConsumer(); 729 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumer", lhsConsumer), LocatorUtils.property(thatLocator, "consumer", rhsConsumer), lhsConsumer, rhsConsumer)) { 730 return false; 731 } 732 } 733 { 734 String lhsConsumerConnection; 735 lhsConsumerConnection = this.getConsumerConnection(); 736 String rhsConsumerConnection; 737 rhsConsumerConnection = that.getConsumerConnection(); 738 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumerConnection", lhsConsumerConnection), LocatorUtils.property(thatLocator, "consumerConnection", rhsConsumerConnection), lhsConsumerConnection, rhsConsumerConnection)) { 739 return false; 740 } 741 } 742 { 743 String lhsConsumerQueue; 744 lhsConsumerQueue = this.getConsumerQueue(); 745 String rhsConsumerQueue; 746 rhsConsumerQueue = that.getConsumerQueue(); 747 if (!strategy.equals(LocatorUtils.property(thisLocator, "consumerQueue", lhsConsumerQueue), LocatorUtils.property(thatLocator, "consumerQueue", rhsConsumerQueue), lhsConsumerQueue, rhsConsumerQueue)) { 748 return false; 749 } 750 } 751 { 752 Boolean lhsDoHandleReplyTo; 753 lhsDoHandleReplyTo = this.isDoHandleReplyTo(); 754 Boolean rhsDoHandleReplyTo; 755 rhsDoHandleReplyTo = that.isDoHandleReplyTo(); 756 if (!strategy.equals(LocatorUtils.property(thisLocator, "doHandleReplyTo", lhsDoHandleReplyTo), LocatorUtils.property(thatLocator, "doHandleReplyTo", rhsDoHandleReplyTo), lhsDoHandleReplyTo, rhsDoHandleReplyTo)) { 757 return false; 758 } 759 } 760 { 761 String lhsJmsConnector; 762 lhsJmsConnector = this.getJmsConnector(); 763 String rhsJmsConnector; 764 rhsJmsConnector = that.getJmsConnector(); 765 if (!strategy.equals(LocatorUtils.property(thisLocator, "jmsConnector", lhsJmsConnector), LocatorUtils.property(thatLocator, "jmsConnector", rhsJmsConnector), lhsJmsConnector, rhsJmsConnector)) { 766 return false; 767 } 768 } 769 { 770 String lhsJmsMessageConvertor; 771 lhsJmsMessageConvertor = this.getJmsMessageConvertor(); 772 String rhsJmsMessageConvertor; 773 rhsJmsMessageConvertor = that.getJmsMessageConvertor(); 774 if (!strategy.equals(LocatorUtils.property(thisLocator, "jmsMessageConvertor", lhsJmsMessageConvertor), LocatorUtils.property(thatLocator, "jmsMessageConvertor", rhsJmsMessageConvertor), lhsJmsMessageConvertor, rhsJmsMessageConvertor)) { 775 return false; 776 } 777 } 778 { 779 String lhsLocalQueueName; 780 lhsLocalQueueName = this.getLocalQueueName(); 781 String rhsLocalQueueName; 782 rhsLocalQueueName = that.getLocalQueueName(); 783 if (!strategy.equals(LocatorUtils.property(thisLocator, "localQueueName", lhsLocalQueueName), LocatorUtils.property(thatLocator, "localQueueName", rhsLocalQueueName), lhsLocalQueueName, rhsLocalQueueName)) { 784 return false; 785 } 786 } 787 { 788 String lhsOutboundQueueName; 789 lhsOutboundQueueName = this.getOutboundQueueName(); 790 String rhsOutboundQueueName; 791 rhsOutboundQueueName = that.getOutboundQueueName(); 792 if (!strategy.equals(LocatorUtils.property(thisLocator, "outboundQueueName", lhsOutboundQueueName), LocatorUtils.property(thatLocator, "outboundQueueName", rhsOutboundQueueName), lhsOutboundQueueName, rhsOutboundQueueName)) { 793 return false; 794 } 795 } 796 { 797 String lhsProducerConnection; 798 lhsProducerConnection = this.getProducerConnection(); 799 String rhsProducerConnection; 800 rhsProducerConnection = that.getProducerConnection(); 801 if (!strategy.equals(LocatorUtils.property(thisLocator, "producerConnection", lhsProducerConnection), LocatorUtils.property(thatLocator, "producerConnection", rhsProducerConnection), lhsProducerConnection, rhsProducerConnection)) { 802 return false; 803 } 804 } 805 { 806 String lhsProducerQueue; 807 lhsProducerQueue = this.getProducerQueue(); 808 String rhsProducerQueue; 809 rhsProducerQueue = that.getProducerQueue(); 810 if (!strategy.equals(LocatorUtils.property(thisLocator, "producerQueue", lhsProducerQueue), LocatorUtils.property(thatLocator, "producerQueue", rhsProducerQueue), lhsProducerQueue, rhsProducerQueue)) { 811 return false; 812 } 813 } 814 { 815 String lhsSelector; 816 lhsSelector = this.getSelector(); 817 String rhsSelector; 818 rhsSelector = that.getSelector(); 819 if (!strategy.equals(LocatorUtils.property(thisLocator, "selector", lhsSelector), LocatorUtils.property(thatLocator, "selector", rhsSelector), lhsSelector, rhsSelector)) { 820 return false; 821 } 822 } 823 { 824 String lhsId; 825 lhsId = this.getId(); 826 String rhsId; 827 rhsId = that.getId(); 828 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 829 return false; 830 } 831 } 832 return true; 833 } 834 835 public boolean equals(Object object) { 836 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 837 return equals(null, null, object, strategy); 838 } 839 840 841 /** 842 * <p>Java class for anonymous complex type. 843 * 844 * <p>The following schema fragment specifies the expected content contained within this class. 845 * 846 * <pre> 847 * <complexType> 848 * <complexContent> 849 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 850 * <sequence minOccurs="0"> 851 * <any maxOccurs="unbounded" minOccurs="0"/> 852 * </sequence> 853 * </restriction> 854 * </complexContent> 855 * </complexType> 856 * </pre> 857 * 858 * 859 */ 860 @XmlAccessorType(XmlAccessType.FIELD) 861 @XmlType(name = "", propOrder = { 862 "any" 863 }) 864 public static class Consumer 865 implements Equals, HashCode, ToString 866 { 867 868 @XmlAnyElement(lax = true) 869 protected List<Object> any; 870 871 /** 872 * Gets the value of the any property. 873 * 874 * <p> 875 * This accessor method returns a reference to the live list, 876 * not a snapshot. Therefore any modification you make to the 877 * returned list will be present inside the JAXB object. 878 * This is why there is not a <CODE>set</CODE> method for the any property. 879 * 880 * <p> 881 * For example, to add a new item, do as follows: 882 * <pre> 883 * getAny().add(newItem); 884 * </pre> 885 * 886 * 887 * <p> 888 * Objects of the following type(s) are allowed in the list 889 * {@link Object } 890 * 891 * 892 */ 893 public List<Object> getAny() { 894 if (any == null) { 895 any = new ArrayList<Object>(); 896 } 897 return this.any; 898 } 899 900 public String toString() { 901 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 902 final StringBuilder buffer = new StringBuilder(); 903 append(null, buffer, strategy); 904 return buffer.toString(); 905 } 906 907 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 908 strategy.appendStart(locator, this, buffer); 909 appendFields(locator, buffer, strategy); 910 strategy.appendEnd(locator, this, buffer); 911 return buffer; 912 } 913 914 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 915 { 916 List<Object> theAny; 917 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 918 strategy.appendField(locator, this, "any", buffer, theAny); 919 } 920 return buffer; 921 } 922 923 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 924 int currentHashCode = 1; 925 { 926 List<Object> theAny; 927 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 928 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 929 } 930 return currentHashCode; 931 } 932 933 public int hashCode() { 934 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 935 return this.hashCode(null, strategy); 936 } 937 938 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 939 if (!(object instanceof DtoOutboundQueueBridge.Consumer)) { 940 return false; 941 } 942 if (this == object) { 943 return true; 944 } 945 final DtoOutboundQueueBridge.Consumer that = ((DtoOutboundQueueBridge.Consumer) object); 946 { 947 List<Object> lhsAny; 948 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 949 List<Object> rhsAny; 950 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 951 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 952 return false; 953 } 954 } 955 return true; 956 } 957 958 public boolean equals(Object object) { 959 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 960 return equals(null, null, object, strategy); 961 } 962 963 } 964 965 966 /** 967 * <p>Java class for anonymous complex type. 968 * 969 * <p>The following schema fragment specifies the expected content contained within this class. 970 * 971 * <pre> 972 * <complexType> 973 * <complexContent> 974 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 975 * <sequence minOccurs="0"> 976 * <any maxOccurs="unbounded" minOccurs="0"/> 977 * </sequence> 978 * </restriction> 979 * </complexContent> 980 * </complexType> 981 * </pre> 982 * 983 * 984 */ 985 @XmlAccessorType(XmlAccessType.FIELD) 986 @XmlType(name = "", propOrder = { 987 "any" 988 }) 989 public static class ConsumerConnection 990 implements Equals, HashCode, ToString 991 { 992 993 @XmlAnyElement(lax = true) 994 protected List<Object> any; 995 996 /** 997 * Gets the value of the any property. 998 * 999 * <p> 1000 * This accessor method returns a reference to the live list, 1001 * not a snapshot. Therefore any modification you make to the 1002 * returned list will be present inside the JAXB object. 1003 * This is why there is not a <CODE>set</CODE> method for the any property. 1004 * 1005 * <p> 1006 * For example, to add a new item, do as follows: 1007 * <pre> 1008 * getAny().add(newItem); 1009 * </pre> 1010 * 1011 * 1012 * <p> 1013 * Objects of the following type(s) are allowed in the list 1014 * {@link Object } 1015 * 1016 * 1017 */ 1018 public List<Object> getAny() { 1019 if (any == null) { 1020 any = new ArrayList<Object>(); 1021 } 1022 return this.any; 1023 } 1024 1025 public String toString() { 1026 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1027 final StringBuilder buffer = new StringBuilder(); 1028 append(null, buffer, strategy); 1029 return buffer.toString(); 1030 } 1031 1032 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1033 strategy.appendStart(locator, this, buffer); 1034 appendFields(locator, buffer, strategy); 1035 strategy.appendEnd(locator, this, buffer); 1036 return buffer; 1037 } 1038 1039 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1040 { 1041 List<Object> theAny; 1042 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1043 strategy.appendField(locator, this, "any", buffer, theAny); 1044 } 1045 return buffer; 1046 } 1047 1048 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1049 int currentHashCode = 1; 1050 { 1051 List<Object> theAny; 1052 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1053 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1054 } 1055 return currentHashCode; 1056 } 1057 1058 public int hashCode() { 1059 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1060 return this.hashCode(null, strategy); 1061 } 1062 1063 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1064 if (!(object instanceof DtoOutboundQueueBridge.ConsumerConnection)) { 1065 return false; 1066 } 1067 if (this == object) { 1068 return true; 1069 } 1070 final DtoOutboundQueueBridge.ConsumerConnection that = ((DtoOutboundQueueBridge.ConsumerConnection) object); 1071 { 1072 List<Object> lhsAny; 1073 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1074 List<Object> rhsAny; 1075 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 1076 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1077 return false; 1078 } 1079 } 1080 return true; 1081 } 1082 1083 public boolean equals(Object object) { 1084 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1085 return equals(null, null, object, strategy); 1086 } 1087 1088 } 1089 1090 1091 /** 1092 * <p>Java class for anonymous complex type. 1093 * 1094 * <p>The following schema fragment specifies the expected content contained within this class. 1095 * 1096 * <pre> 1097 * <complexType> 1098 * <complexContent> 1099 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1100 * <choice minOccurs="0"> 1101 * <element ref="{http://activemq.apache.org/schema/core}queue"/> 1102 * <any namespace='##other'/> 1103 * </choice> 1104 * </restriction> 1105 * </complexContent> 1106 * </complexType> 1107 * </pre> 1108 * 1109 * 1110 */ 1111 @XmlAccessorType(XmlAccessType.FIELD) 1112 @XmlType(name = "", propOrder = { 1113 "queue", 1114 "any" 1115 }) 1116 public static class ConsumerQueue 1117 implements Equals, HashCode, ToString 1118 { 1119 1120 protected DtoQueue queue; 1121 @XmlAnyElement(lax = true) 1122 protected Object any; 1123 1124 /** 1125 * Gets the value of the queue property. 1126 * 1127 * @return 1128 * possible object is 1129 * {@link DtoQueue } 1130 * 1131 */ 1132 public DtoQueue getQueue() { 1133 return queue; 1134 } 1135 1136 /** 1137 * Sets the value of the queue property. 1138 * 1139 * @param value 1140 * allowed object is 1141 * {@link DtoQueue } 1142 * 1143 */ 1144 public void setQueue(DtoQueue value) { 1145 this.queue = value; 1146 } 1147 1148 /** 1149 * Gets the value of the any property. 1150 * 1151 * @return 1152 * possible object is 1153 * {@link Object } 1154 * 1155 */ 1156 public Object getAny() { 1157 return any; 1158 } 1159 1160 /** 1161 * Sets the value of the any property. 1162 * 1163 * @param value 1164 * allowed object is 1165 * {@link Object } 1166 * 1167 */ 1168 public void setAny(Object value) { 1169 this.any = value; 1170 } 1171 1172 public String toString() { 1173 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1174 final StringBuilder buffer = new StringBuilder(); 1175 append(null, buffer, strategy); 1176 return buffer.toString(); 1177 } 1178 1179 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1180 strategy.appendStart(locator, this, buffer); 1181 appendFields(locator, buffer, strategy); 1182 strategy.appendEnd(locator, this, buffer); 1183 return buffer; 1184 } 1185 1186 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1187 { 1188 DtoQueue theQueue; 1189 theQueue = this.getQueue(); 1190 strategy.appendField(locator, this, "queue", buffer, theQueue); 1191 } 1192 { 1193 Object theAny; 1194 theAny = this.getAny(); 1195 strategy.appendField(locator, this, "any", buffer, theAny); 1196 } 1197 return buffer; 1198 } 1199 1200 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1201 int currentHashCode = 1; 1202 { 1203 DtoQueue theQueue; 1204 theQueue = this.getQueue(); 1205 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "queue", theQueue), currentHashCode, theQueue); 1206 } 1207 { 1208 Object theAny; 1209 theAny = this.getAny(); 1210 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1211 } 1212 return currentHashCode; 1213 } 1214 1215 public int hashCode() { 1216 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1217 return this.hashCode(null, strategy); 1218 } 1219 1220 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1221 if (!(object instanceof DtoOutboundQueueBridge.ConsumerQueue)) { 1222 return false; 1223 } 1224 if (this == object) { 1225 return true; 1226 } 1227 final DtoOutboundQueueBridge.ConsumerQueue that = ((DtoOutboundQueueBridge.ConsumerQueue) object); 1228 { 1229 DtoQueue lhsQueue; 1230 lhsQueue = this.getQueue(); 1231 DtoQueue rhsQueue; 1232 rhsQueue = that.getQueue(); 1233 if (!strategy.equals(LocatorUtils.property(thisLocator, "queue", lhsQueue), LocatorUtils.property(thatLocator, "queue", rhsQueue), lhsQueue, rhsQueue)) { 1234 return false; 1235 } 1236 } 1237 { 1238 Object lhsAny; 1239 lhsAny = this.getAny(); 1240 Object rhsAny; 1241 rhsAny = that.getAny(); 1242 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1243 return false; 1244 } 1245 } 1246 return true; 1247 } 1248 1249 public boolean equals(Object object) { 1250 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1251 return equals(null, null, object, strategy); 1252 } 1253 1254 } 1255 1256 1257 /** 1258 * <p>Java class for anonymous complex type. 1259 * 1260 * <p>The following schema fragment specifies the expected content contained within this class. 1261 * 1262 * <pre> 1263 * <complexType> 1264 * <complexContent> 1265 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1266 * <choice minOccurs="0"> 1267 * <element ref="{http://activemq.apache.org/schema/core}jmsQueueConnector"/> 1268 * <element ref="{http://activemq.apache.org/schema/core}jmsTopicConnector"/> 1269 * <any namespace='##other'/> 1270 * </choice> 1271 * </restriction> 1272 * </complexContent> 1273 * </complexType> 1274 * </pre> 1275 * 1276 * 1277 */ 1278 @XmlAccessorType(XmlAccessType.FIELD) 1279 @XmlType(name = "", propOrder = { 1280 "jmsQueueConnector", 1281 "jmsTopicConnector", 1282 "any" 1283 }) 1284 public static class JmsConnector 1285 implements Equals, HashCode, ToString 1286 { 1287 1288 protected DtoJmsQueueConnector jmsQueueConnector; 1289 protected DtoJmsTopicConnector jmsTopicConnector; 1290 @XmlAnyElement(lax = true) 1291 protected Object any; 1292 1293 /** 1294 * Gets the value of the jmsQueueConnector property. 1295 * 1296 * @return 1297 * possible object is 1298 * {@link DtoJmsQueueConnector } 1299 * 1300 */ 1301 public DtoJmsQueueConnector getJmsQueueConnector() { 1302 return jmsQueueConnector; 1303 } 1304 1305 /** 1306 * Sets the value of the jmsQueueConnector property. 1307 * 1308 * @param value 1309 * allowed object is 1310 * {@link DtoJmsQueueConnector } 1311 * 1312 */ 1313 public void setJmsQueueConnector(DtoJmsQueueConnector value) { 1314 this.jmsQueueConnector = value; 1315 } 1316 1317 /** 1318 * Gets the value of the jmsTopicConnector property. 1319 * 1320 * @return 1321 * possible object is 1322 * {@link DtoJmsTopicConnector } 1323 * 1324 */ 1325 public DtoJmsTopicConnector getJmsTopicConnector() { 1326 return jmsTopicConnector; 1327 } 1328 1329 /** 1330 * Sets the value of the jmsTopicConnector property. 1331 * 1332 * @param value 1333 * allowed object is 1334 * {@link DtoJmsTopicConnector } 1335 * 1336 */ 1337 public void setJmsTopicConnector(DtoJmsTopicConnector value) { 1338 this.jmsTopicConnector = value; 1339 } 1340 1341 /** 1342 * Gets the value of the any property. 1343 * 1344 * @return 1345 * possible object is 1346 * {@link Object } 1347 * 1348 */ 1349 public Object getAny() { 1350 return any; 1351 } 1352 1353 /** 1354 * Sets the value of the any property. 1355 * 1356 * @param value 1357 * allowed object is 1358 * {@link Object } 1359 * 1360 */ 1361 public void setAny(Object value) { 1362 this.any = value; 1363 } 1364 1365 public String toString() { 1366 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1367 final StringBuilder buffer = new StringBuilder(); 1368 append(null, buffer, strategy); 1369 return buffer.toString(); 1370 } 1371 1372 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1373 strategy.appendStart(locator, this, buffer); 1374 appendFields(locator, buffer, strategy); 1375 strategy.appendEnd(locator, this, buffer); 1376 return buffer; 1377 } 1378 1379 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1380 { 1381 DtoJmsQueueConnector theJmsQueueConnector; 1382 theJmsQueueConnector = this.getJmsQueueConnector(); 1383 strategy.appendField(locator, this, "jmsQueueConnector", buffer, theJmsQueueConnector); 1384 } 1385 { 1386 DtoJmsTopicConnector theJmsTopicConnector; 1387 theJmsTopicConnector = this.getJmsTopicConnector(); 1388 strategy.appendField(locator, this, "jmsTopicConnector", buffer, theJmsTopicConnector); 1389 } 1390 { 1391 Object theAny; 1392 theAny = this.getAny(); 1393 strategy.appendField(locator, this, "any", buffer, theAny); 1394 } 1395 return buffer; 1396 } 1397 1398 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1399 int currentHashCode = 1; 1400 { 1401 DtoJmsQueueConnector theJmsQueueConnector; 1402 theJmsQueueConnector = this.getJmsQueueConnector(); 1403 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "jmsQueueConnector", theJmsQueueConnector), currentHashCode, theJmsQueueConnector); 1404 } 1405 { 1406 DtoJmsTopicConnector theJmsTopicConnector; 1407 theJmsTopicConnector = this.getJmsTopicConnector(); 1408 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "jmsTopicConnector", theJmsTopicConnector), currentHashCode, theJmsTopicConnector); 1409 } 1410 { 1411 Object theAny; 1412 theAny = this.getAny(); 1413 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1414 } 1415 return currentHashCode; 1416 } 1417 1418 public int hashCode() { 1419 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1420 return this.hashCode(null, strategy); 1421 } 1422 1423 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1424 if (!(object instanceof DtoOutboundQueueBridge.JmsConnector)) { 1425 return false; 1426 } 1427 if (this == object) { 1428 return true; 1429 } 1430 final DtoOutboundQueueBridge.JmsConnector that = ((DtoOutboundQueueBridge.JmsConnector) object); 1431 { 1432 DtoJmsQueueConnector lhsJmsQueueConnector; 1433 lhsJmsQueueConnector = this.getJmsQueueConnector(); 1434 DtoJmsQueueConnector rhsJmsQueueConnector; 1435 rhsJmsQueueConnector = that.getJmsQueueConnector(); 1436 if (!strategy.equals(LocatorUtils.property(thisLocator, "jmsQueueConnector", lhsJmsQueueConnector), LocatorUtils.property(thatLocator, "jmsQueueConnector", rhsJmsQueueConnector), lhsJmsQueueConnector, rhsJmsQueueConnector)) { 1437 return false; 1438 } 1439 } 1440 { 1441 DtoJmsTopicConnector lhsJmsTopicConnector; 1442 lhsJmsTopicConnector = this.getJmsTopicConnector(); 1443 DtoJmsTopicConnector rhsJmsTopicConnector; 1444 rhsJmsTopicConnector = that.getJmsTopicConnector(); 1445 if (!strategy.equals(LocatorUtils.property(thisLocator, "jmsTopicConnector", lhsJmsTopicConnector), LocatorUtils.property(thatLocator, "jmsTopicConnector", rhsJmsTopicConnector), lhsJmsTopicConnector, rhsJmsTopicConnector)) { 1446 return false; 1447 } 1448 } 1449 { 1450 Object lhsAny; 1451 lhsAny = this.getAny(); 1452 Object rhsAny; 1453 rhsAny = that.getAny(); 1454 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1455 return false; 1456 } 1457 } 1458 return true; 1459 } 1460 1461 public boolean equals(Object object) { 1462 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1463 return equals(null, null, object, strategy); 1464 } 1465 1466 } 1467 1468 1469 /** 1470 * <p>Java class for anonymous complex type. 1471 * 1472 * <p>The following schema fragment specifies the expected content contained within this class. 1473 * 1474 * <pre> 1475 * <complexType> 1476 * <complexContent> 1477 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1478 * <choice minOccurs="0"> 1479 * <element ref="{http://activemq.apache.org/schema/core}simpleJmsMessageConvertor"/> 1480 * <any namespace='##other'/> 1481 * </choice> 1482 * </restriction> 1483 * </complexContent> 1484 * </complexType> 1485 * </pre> 1486 * 1487 * 1488 */ 1489 @XmlAccessorType(XmlAccessType.FIELD) 1490 @XmlType(name = "", propOrder = { 1491 "simpleJmsMessageConvertor", 1492 "any" 1493 }) 1494 public static class JmsMessageConvertor 1495 implements Equals, HashCode, ToString 1496 { 1497 1498 protected DtoSimpleJmsMessageConvertor simpleJmsMessageConvertor; 1499 @XmlAnyElement(lax = true) 1500 protected Object any; 1501 1502 /** 1503 * Gets the value of the simpleJmsMessageConvertor property. 1504 * 1505 * @return 1506 * possible object is 1507 * {@link DtoSimpleJmsMessageConvertor } 1508 * 1509 */ 1510 public DtoSimpleJmsMessageConvertor getSimpleJmsMessageConvertor() { 1511 return simpleJmsMessageConvertor; 1512 } 1513 1514 /** 1515 * Sets the value of the simpleJmsMessageConvertor property. 1516 * 1517 * @param value 1518 * allowed object is 1519 * {@link DtoSimpleJmsMessageConvertor } 1520 * 1521 */ 1522 public void setSimpleJmsMessageConvertor(DtoSimpleJmsMessageConvertor value) { 1523 this.simpleJmsMessageConvertor = value; 1524 } 1525 1526 /** 1527 * Gets the value of the any property. 1528 * 1529 * @return 1530 * possible object is 1531 * {@link Object } 1532 * 1533 */ 1534 public Object getAny() { 1535 return any; 1536 } 1537 1538 /** 1539 * Sets the value of the any property. 1540 * 1541 * @param value 1542 * allowed object is 1543 * {@link Object } 1544 * 1545 */ 1546 public void setAny(Object value) { 1547 this.any = value; 1548 } 1549 1550 public String toString() { 1551 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1552 final StringBuilder buffer = new StringBuilder(); 1553 append(null, buffer, strategy); 1554 return buffer.toString(); 1555 } 1556 1557 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1558 strategy.appendStart(locator, this, buffer); 1559 appendFields(locator, buffer, strategy); 1560 strategy.appendEnd(locator, this, buffer); 1561 return buffer; 1562 } 1563 1564 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1565 { 1566 DtoSimpleJmsMessageConvertor theSimpleJmsMessageConvertor; 1567 theSimpleJmsMessageConvertor = this.getSimpleJmsMessageConvertor(); 1568 strategy.appendField(locator, this, "simpleJmsMessageConvertor", buffer, theSimpleJmsMessageConvertor); 1569 } 1570 { 1571 Object theAny; 1572 theAny = this.getAny(); 1573 strategy.appendField(locator, this, "any", buffer, theAny); 1574 } 1575 return buffer; 1576 } 1577 1578 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1579 int currentHashCode = 1; 1580 { 1581 DtoSimpleJmsMessageConvertor theSimpleJmsMessageConvertor; 1582 theSimpleJmsMessageConvertor = this.getSimpleJmsMessageConvertor(); 1583 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "simpleJmsMessageConvertor", theSimpleJmsMessageConvertor), currentHashCode, theSimpleJmsMessageConvertor); 1584 } 1585 { 1586 Object theAny; 1587 theAny = this.getAny(); 1588 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1589 } 1590 return currentHashCode; 1591 } 1592 1593 public int hashCode() { 1594 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1595 return this.hashCode(null, strategy); 1596 } 1597 1598 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1599 if (!(object instanceof DtoOutboundQueueBridge.JmsMessageConvertor)) { 1600 return false; 1601 } 1602 if (this == object) { 1603 return true; 1604 } 1605 final DtoOutboundQueueBridge.JmsMessageConvertor that = ((DtoOutboundQueueBridge.JmsMessageConvertor) object); 1606 { 1607 DtoSimpleJmsMessageConvertor lhsSimpleJmsMessageConvertor; 1608 lhsSimpleJmsMessageConvertor = this.getSimpleJmsMessageConvertor(); 1609 DtoSimpleJmsMessageConvertor rhsSimpleJmsMessageConvertor; 1610 rhsSimpleJmsMessageConvertor = that.getSimpleJmsMessageConvertor(); 1611 if (!strategy.equals(LocatorUtils.property(thisLocator, "simpleJmsMessageConvertor", lhsSimpleJmsMessageConvertor), LocatorUtils.property(thatLocator, "simpleJmsMessageConvertor", rhsSimpleJmsMessageConvertor), lhsSimpleJmsMessageConvertor, rhsSimpleJmsMessageConvertor)) { 1612 return false; 1613 } 1614 } 1615 { 1616 Object lhsAny; 1617 lhsAny = this.getAny(); 1618 Object rhsAny; 1619 rhsAny = that.getAny(); 1620 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1621 return false; 1622 } 1623 } 1624 return true; 1625 } 1626 1627 public boolean equals(Object object) { 1628 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1629 return equals(null, null, object, strategy); 1630 } 1631 1632 } 1633 1634 1635 /** 1636 * <p>Java class for anonymous complex type. 1637 * 1638 * <p>The following schema fragment specifies the expected content contained within this class. 1639 * 1640 * <pre> 1641 * <complexType> 1642 * <complexContent> 1643 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1644 * <sequence minOccurs="0"> 1645 * <any maxOccurs="unbounded" minOccurs="0"/> 1646 * </sequence> 1647 * </restriction> 1648 * </complexContent> 1649 * </complexType> 1650 * </pre> 1651 * 1652 * 1653 */ 1654 @XmlAccessorType(XmlAccessType.FIELD) 1655 @XmlType(name = "", propOrder = { 1656 "any" 1657 }) 1658 public static class ProducerConnection 1659 implements Equals, HashCode, ToString 1660 { 1661 1662 @XmlAnyElement(lax = true) 1663 protected List<Object> any; 1664 1665 /** 1666 * Gets the value of the any property. 1667 * 1668 * <p> 1669 * This accessor method returns a reference to the live list, 1670 * not a snapshot. Therefore any modification you make to the 1671 * returned list will be present inside the JAXB object. 1672 * This is why there is not a <CODE>set</CODE> method for the any property. 1673 * 1674 * <p> 1675 * For example, to add a new item, do as follows: 1676 * <pre> 1677 * getAny().add(newItem); 1678 * </pre> 1679 * 1680 * 1681 * <p> 1682 * Objects of the following type(s) are allowed in the list 1683 * {@link Object } 1684 * 1685 * 1686 */ 1687 public List<Object> getAny() { 1688 if (any == null) { 1689 any = new ArrayList<Object>(); 1690 } 1691 return this.any; 1692 } 1693 1694 public String toString() { 1695 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1696 final StringBuilder buffer = new StringBuilder(); 1697 append(null, buffer, strategy); 1698 return buffer.toString(); 1699 } 1700 1701 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1702 strategy.appendStart(locator, this, buffer); 1703 appendFields(locator, buffer, strategy); 1704 strategy.appendEnd(locator, this, buffer); 1705 return buffer; 1706 } 1707 1708 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1709 { 1710 List<Object> theAny; 1711 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1712 strategy.appendField(locator, this, "any", buffer, theAny); 1713 } 1714 return buffer; 1715 } 1716 1717 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1718 int currentHashCode = 1; 1719 { 1720 List<Object> theAny; 1721 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1722 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1723 } 1724 return currentHashCode; 1725 } 1726 1727 public int hashCode() { 1728 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1729 return this.hashCode(null, strategy); 1730 } 1731 1732 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1733 if (!(object instanceof DtoOutboundQueueBridge.ProducerConnection)) { 1734 return false; 1735 } 1736 if (this == object) { 1737 return true; 1738 } 1739 final DtoOutboundQueueBridge.ProducerConnection that = ((DtoOutboundQueueBridge.ProducerConnection) object); 1740 { 1741 List<Object> lhsAny; 1742 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1743 List<Object> rhsAny; 1744 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 1745 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1746 return false; 1747 } 1748 } 1749 return true; 1750 } 1751 1752 public boolean equals(Object object) { 1753 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1754 return equals(null, null, object, strategy); 1755 } 1756 1757 } 1758 1759 1760 /** 1761 * <p>Java class for anonymous complex type. 1762 * 1763 * <p>The following schema fragment specifies the expected content contained within this class. 1764 * 1765 * <pre> 1766 * <complexType> 1767 * <complexContent> 1768 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1769 * <choice minOccurs="0"> 1770 * <element ref="{http://activemq.apache.org/schema/core}queue"/> 1771 * <any namespace='##other'/> 1772 * </choice> 1773 * </restriction> 1774 * </complexContent> 1775 * </complexType> 1776 * </pre> 1777 * 1778 * 1779 */ 1780 @XmlAccessorType(XmlAccessType.FIELD) 1781 @XmlType(name = "", propOrder = { 1782 "queue", 1783 "any" 1784 }) 1785 public static class ProducerQueue 1786 implements Equals, HashCode, ToString 1787 { 1788 1789 protected DtoQueue queue; 1790 @XmlAnyElement(lax = true) 1791 protected Object any; 1792 1793 /** 1794 * Gets the value of the queue property. 1795 * 1796 * @return 1797 * possible object is 1798 * {@link DtoQueue } 1799 * 1800 */ 1801 public DtoQueue getQueue() { 1802 return queue; 1803 } 1804 1805 /** 1806 * Sets the value of the queue property. 1807 * 1808 * @param value 1809 * allowed object is 1810 * {@link DtoQueue } 1811 * 1812 */ 1813 public void setQueue(DtoQueue value) { 1814 this.queue = value; 1815 } 1816 1817 /** 1818 * Gets the value of the any property. 1819 * 1820 * @return 1821 * possible object is 1822 * {@link Object } 1823 * 1824 */ 1825 public Object getAny() { 1826 return any; 1827 } 1828 1829 /** 1830 * Sets the value of the any property. 1831 * 1832 * @param value 1833 * allowed object is 1834 * {@link Object } 1835 * 1836 */ 1837 public void setAny(Object value) { 1838 this.any = value; 1839 } 1840 1841 public String toString() { 1842 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1843 final StringBuilder buffer = new StringBuilder(); 1844 append(null, buffer, strategy); 1845 return buffer.toString(); 1846 } 1847 1848 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1849 strategy.appendStart(locator, this, buffer); 1850 appendFields(locator, buffer, strategy); 1851 strategy.appendEnd(locator, this, buffer); 1852 return buffer; 1853 } 1854 1855 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1856 { 1857 DtoQueue theQueue; 1858 theQueue = this.getQueue(); 1859 strategy.appendField(locator, this, "queue", buffer, theQueue); 1860 } 1861 { 1862 Object theAny; 1863 theAny = this.getAny(); 1864 strategy.appendField(locator, this, "any", buffer, theAny); 1865 } 1866 return buffer; 1867 } 1868 1869 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1870 int currentHashCode = 1; 1871 { 1872 DtoQueue theQueue; 1873 theQueue = this.getQueue(); 1874 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "queue", theQueue), currentHashCode, theQueue); 1875 } 1876 { 1877 Object theAny; 1878 theAny = this.getAny(); 1879 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1880 } 1881 return currentHashCode; 1882 } 1883 1884 public int hashCode() { 1885 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1886 return this.hashCode(null, strategy); 1887 } 1888 1889 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1890 if (!(object instanceof DtoOutboundQueueBridge.ProducerQueue)) { 1891 return false; 1892 } 1893 if (this == object) { 1894 return true; 1895 } 1896 final DtoOutboundQueueBridge.ProducerQueue that = ((DtoOutboundQueueBridge.ProducerQueue) object); 1897 { 1898 DtoQueue lhsQueue; 1899 lhsQueue = this.getQueue(); 1900 DtoQueue rhsQueue; 1901 rhsQueue = that.getQueue(); 1902 if (!strategy.equals(LocatorUtils.property(thisLocator, "queue", lhsQueue), LocatorUtils.property(thatLocator, "queue", rhsQueue), lhsQueue, rhsQueue)) { 1903 return false; 1904 } 1905 } 1906 { 1907 Object lhsAny; 1908 lhsAny = this.getAny(); 1909 Object rhsAny; 1910 rhsAny = that.getAny(); 1911 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1912 return false; 1913 } 1914 } 1915 return true; 1916 } 1917 1918 public boolean equals(Object object) { 1919 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1920 return equals(null, null, object, strategy); 1921 } 1922 1923 } 1924 1925}