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.07.25 at 01:05:24 PM EDT 006// 007 008 009package org.apache.activemq.schema.core; 010 011import java.math.BigInteger; 012import java.util.ArrayList; 013import java.util.HashMap; 014import java.util.List; 015import java.util.Map; 016import javax.xml.bind.JAXBElement; 017import javax.xml.bind.annotation.XmlAccessType; 018import javax.xml.bind.annotation.XmlAccessorType; 019import javax.xml.bind.annotation.XmlAnyAttribute; 020import javax.xml.bind.annotation.XmlAnyElement; 021import javax.xml.bind.annotation.XmlAttribute; 022import javax.xml.bind.annotation.XmlElementRef; 023import javax.xml.bind.annotation.XmlElementRefs; 024import javax.xml.bind.annotation.XmlID; 025import javax.xml.bind.annotation.XmlRootElement; 026import javax.xml.bind.annotation.XmlSchemaType; 027import javax.xml.bind.annotation.XmlType; 028import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; 029import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 030import javax.xml.namespace.QName; 031import org.jvnet.jaxb2_commons.lang.Equals; 032import org.jvnet.jaxb2_commons.lang.EqualsStrategy; 033import org.jvnet.jaxb2_commons.lang.HashCode; 034import org.jvnet.jaxb2_commons.lang.HashCodeStrategy; 035import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy; 036import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; 037import org.jvnet.jaxb2_commons.lang.ToString; 038import org.jvnet.jaxb2_commons.lang.ToStringStrategy; 039import org.jvnet.jaxb2_commons.locator.ObjectLocator; 040import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; 041 042 043/** 044 * <p>Java class for anonymous complex type. 045 * 046 * <p>The following schema fragment specifies the expected content contained within this class. 047 * 048 * <pre> 049 * <complexType> 050 * <complexContent> 051 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 052 * <choice maxOccurs="unbounded" minOccurs="0"> 053 * <choice> 054 * <element name="executor" minOccurs="0"> 055 * <complexType> 056 * <complexContent> 057 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 058 * <sequence minOccurs="0"> 059 * <any maxOccurs="unbounded" minOccurs="0"/> 060 * </sequence> 061 * </restriction> 062 * </complexContent> 063 * </complexType> 064 * </element> 065 * <element name="rejectedTaskHandler" minOccurs="0"> 066 * <complexType> 067 * <complexContent> 068 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 069 * <sequence minOccurs="0"> 070 * <any maxOccurs="unbounded" minOccurs="0"/> 071 * </sequence> 072 * </restriction> 073 * </complexContent> 074 * </complexType> 075 * </element> 076 * <element name="threadClassLoader" minOccurs="0"> 077 * <complexType> 078 * <complexContent> 079 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 080 * <sequence minOccurs="0"> 081 * <any maxOccurs="unbounded" minOccurs="0"/> 082 * </sequence> 083 * </restriction> 084 * </complexContent> 085 * </complexType> 086 * </element> 087 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 088 * </choice> 089 * </choice> 090 * <attribute name="daemon" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 091 * <attribute name="dedicatedTaskRunner" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 092 * <attribute name="executor" type="{http://www.w3.org/2001/XMLSchema}string" /> 093 * <attribute name="maxIterationsPerRun" type="{http://www.w3.org/2001/XMLSchema}integer" /> 094 * <attribute name="maxThreadPoolSize" type="{http://www.w3.org/2001/XMLSchema}integer" /> 095 * <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" /> 096 * <attribute name="priority" type="{http://www.w3.org/2001/XMLSchema}integer" /> 097 * <attribute name="rejectedTaskHandler" type="{http://www.w3.org/2001/XMLSchema}string" /> 098 * <attribute name="shutdownAwaitTermination" type="{http://www.w3.org/2001/XMLSchema}long" /> 099 * <attribute name="threadClassLoader" type="{http://www.w3.org/2001/XMLSchema}string" /> 100 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 101 * <anyAttribute processContents='lax' namespace='##other'/> 102 * </restriction> 103 * </complexContent> 104 * </complexType> 105 * </pre> 106 * 107 * 108 */ 109@XmlAccessorType(XmlAccessType.FIELD) 110@XmlType(name = "", propOrder = { 111 "executorOrRejectedTaskHandlerOrThreadClassLoader" 112}) 113@XmlRootElement(name = "taskRunnerFactory") 114public class DtoTaskRunnerFactory 115 implements Equals, HashCode, ToString 116{ 117 118 @XmlElementRefs({ 119 @XmlElementRef(name = "threadClassLoader", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 120 @XmlElementRef(name = "executor", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 121 @XmlElementRef(name = "rejectedTaskHandler", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 122 }) 123 @XmlAnyElement(lax = true) 124 protected List<Object> executorOrRejectedTaskHandlerOrThreadClassLoader; 125 @XmlAttribute(name = "daemon") 126 protected Boolean daemon; 127 @XmlAttribute(name = "dedicatedTaskRunner") 128 protected Boolean dedicatedTaskRunner; 129 @XmlAttribute(name = "executor") 130 protected String executor; 131 @XmlAttribute(name = "maxIterationsPerRun") 132 protected BigInteger maxIterationsPerRun; 133 @XmlAttribute(name = "maxThreadPoolSize") 134 protected BigInteger maxThreadPoolSize; 135 @XmlAttribute(name = "name") 136 protected String name; 137 @XmlAttribute(name = "priority") 138 protected BigInteger priority; 139 @XmlAttribute(name = "rejectedTaskHandler") 140 protected String rejectedTaskHandler; 141 @XmlAttribute(name = "shutdownAwaitTermination") 142 protected Long shutdownAwaitTermination; 143 @XmlAttribute(name = "threadClassLoader") 144 protected String threadClassLoader; 145 @XmlAttribute(name = "id") 146 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 147 @XmlID 148 @XmlSchemaType(name = "ID") 149 protected String id; 150 @XmlAnyAttribute 151 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 152 153 /** 154 * Gets the value of the executorOrRejectedTaskHandlerOrThreadClassLoader property. 155 * 156 * <p> 157 * This accessor method returns a reference to the live list, 158 * not a snapshot. Therefore any modification you make to the 159 * returned list will be present inside the JAXB object. 160 * This is why there is not a <CODE>set</CODE> method for the executorOrRejectedTaskHandlerOrThreadClassLoader property. 161 * 162 * <p> 163 * For example, to add a new item, do as follows: 164 * <pre> 165 * getExecutorOrRejectedTaskHandlerOrThreadClassLoader().add(newItem); 166 * </pre> 167 * 168 * 169 * <p> 170 * Objects of the following type(s) are allowed in the list 171 * {@link JAXBElement }{@code <}{@link DtoTaskRunnerFactory.ThreadClassLoader }{@code >} 172 * {@link JAXBElement }{@code <}{@link DtoTaskRunnerFactory.RejectedTaskHandler }{@code >} 173 * {@link Object } 174 * {@link JAXBElement }{@code <}{@link DtoTaskRunnerFactory.Executor }{@code >} 175 * 176 * 177 */ 178 public List<Object> getExecutorOrRejectedTaskHandlerOrThreadClassLoader() { 179 if (executorOrRejectedTaskHandlerOrThreadClassLoader == null) { 180 executorOrRejectedTaskHandlerOrThreadClassLoader = new ArrayList<Object>(); 181 } 182 return this.executorOrRejectedTaskHandlerOrThreadClassLoader; 183 } 184 185 /** 186 * Gets the value of the daemon property. 187 * 188 * @return 189 * possible object is 190 * {@link Boolean } 191 * 192 */ 193 public Boolean isDaemon() { 194 return daemon; 195 } 196 197 /** 198 * Sets the value of the daemon property. 199 * 200 * @param value 201 * allowed object is 202 * {@link Boolean } 203 * 204 */ 205 public void setDaemon(Boolean value) { 206 this.daemon = value; 207 } 208 209 /** 210 * Gets the value of the dedicatedTaskRunner property. 211 * 212 * @return 213 * possible object is 214 * {@link Boolean } 215 * 216 */ 217 public Boolean isDedicatedTaskRunner() { 218 return dedicatedTaskRunner; 219 } 220 221 /** 222 * Sets the value of the dedicatedTaskRunner property. 223 * 224 * @param value 225 * allowed object is 226 * {@link Boolean } 227 * 228 */ 229 public void setDedicatedTaskRunner(Boolean value) { 230 this.dedicatedTaskRunner = value; 231 } 232 233 /** 234 * Gets the value of the executor property. 235 * 236 * @return 237 * possible object is 238 * {@link String } 239 * 240 */ 241 public String getExecutor() { 242 return executor; 243 } 244 245 /** 246 * Sets the value of the executor property. 247 * 248 * @param value 249 * allowed object is 250 * {@link String } 251 * 252 */ 253 public void setExecutor(String value) { 254 this.executor = value; 255 } 256 257 /** 258 * Gets the value of the maxIterationsPerRun property. 259 * 260 * @return 261 * possible object is 262 * {@link BigInteger } 263 * 264 */ 265 public BigInteger getMaxIterationsPerRun() { 266 return maxIterationsPerRun; 267 } 268 269 /** 270 * Sets the value of the maxIterationsPerRun property. 271 * 272 * @param value 273 * allowed object is 274 * {@link BigInteger } 275 * 276 */ 277 public void setMaxIterationsPerRun(BigInteger value) { 278 this.maxIterationsPerRun = value; 279 } 280 281 /** 282 * Gets the value of the maxThreadPoolSize property. 283 * 284 * @return 285 * possible object is 286 * {@link BigInteger } 287 * 288 */ 289 public BigInteger getMaxThreadPoolSize() { 290 return maxThreadPoolSize; 291 } 292 293 /** 294 * Sets the value of the maxThreadPoolSize property. 295 * 296 * @param value 297 * allowed object is 298 * {@link BigInteger } 299 * 300 */ 301 public void setMaxThreadPoolSize(BigInteger value) { 302 this.maxThreadPoolSize = value; 303 } 304 305 /** 306 * Gets the value of the name property. 307 * 308 * @return 309 * possible object is 310 * {@link String } 311 * 312 */ 313 public String getName() { 314 return name; 315 } 316 317 /** 318 * Sets the value of the name property. 319 * 320 * @param value 321 * allowed object is 322 * {@link String } 323 * 324 */ 325 public void setName(String value) { 326 this.name = value; 327 } 328 329 /** 330 * Gets the value of the priority property. 331 * 332 * @return 333 * possible object is 334 * {@link BigInteger } 335 * 336 */ 337 public BigInteger getPriority() { 338 return priority; 339 } 340 341 /** 342 * Sets the value of the priority property. 343 * 344 * @param value 345 * allowed object is 346 * {@link BigInteger } 347 * 348 */ 349 public void setPriority(BigInteger value) { 350 this.priority = value; 351 } 352 353 /** 354 * Gets the value of the rejectedTaskHandler property. 355 * 356 * @return 357 * possible object is 358 * {@link String } 359 * 360 */ 361 public String getRejectedTaskHandler() { 362 return rejectedTaskHandler; 363 } 364 365 /** 366 * Sets the value of the rejectedTaskHandler property. 367 * 368 * @param value 369 * allowed object is 370 * {@link String } 371 * 372 */ 373 public void setRejectedTaskHandler(String value) { 374 this.rejectedTaskHandler = value; 375 } 376 377 /** 378 * Gets the value of the shutdownAwaitTermination property. 379 * 380 * @return 381 * possible object is 382 * {@link Long } 383 * 384 */ 385 public Long getShutdownAwaitTermination() { 386 return shutdownAwaitTermination; 387 } 388 389 /** 390 * Sets the value of the shutdownAwaitTermination property. 391 * 392 * @param value 393 * allowed object is 394 * {@link Long } 395 * 396 */ 397 public void setShutdownAwaitTermination(Long value) { 398 this.shutdownAwaitTermination = value; 399 } 400 401 /** 402 * Gets the value of the threadClassLoader property. 403 * 404 * @return 405 * possible object is 406 * {@link String } 407 * 408 */ 409 public String getThreadClassLoader() { 410 return threadClassLoader; 411 } 412 413 /** 414 * Sets the value of the threadClassLoader property. 415 * 416 * @param value 417 * allowed object is 418 * {@link String } 419 * 420 */ 421 public void setThreadClassLoader(String value) { 422 this.threadClassLoader = value; 423 } 424 425 /** 426 * Gets the value of the id property. 427 * 428 * @return 429 * possible object is 430 * {@link String } 431 * 432 */ 433 public String getId() { 434 return id; 435 } 436 437 /** 438 * Sets the value of the id property. 439 * 440 * @param value 441 * allowed object is 442 * {@link String } 443 * 444 */ 445 public void setId(String value) { 446 this.id = value; 447 } 448 449 /** 450 * Gets a map that contains attributes that aren't bound to any typed property on this class. 451 * 452 * <p> 453 * the map is keyed by the name of the attribute and 454 * the value is the string value of the attribute. 455 * 456 * the map returned by this method is live, and you can add new attribute 457 * by updating the map directly. Because of this design, there's no setter. 458 * 459 * 460 * @return 461 * always non-null 462 */ 463 public Map<QName, String> getOtherAttributes() { 464 return otherAttributes; 465 } 466 467 public String toString() { 468 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 469 final StringBuilder buffer = new StringBuilder(); 470 append(null, buffer, strategy); 471 return buffer.toString(); 472 } 473 474 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 475 strategy.appendStart(locator, this, buffer); 476 appendFields(locator, buffer, strategy); 477 strategy.appendEnd(locator, this, buffer); 478 return buffer; 479 } 480 481 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 482 { 483 List<Object> theExecutorOrRejectedTaskHandlerOrThreadClassLoader; 484 theExecutorOrRejectedTaskHandlerOrThreadClassLoader = (((this.executorOrRejectedTaskHandlerOrThreadClassLoader!= null)&&(!this.executorOrRejectedTaskHandlerOrThreadClassLoader.isEmpty()))?this.getExecutorOrRejectedTaskHandlerOrThreadClassLoader():null); 485 strategy.appendField(locator, this, "executorOrRejectedTaskHandlerOrThreadClassLoader", buffer, theExecutorOrRejectedTaskHandlerOrThreadClassLoader); 486 } 487 { 488 Boolean theDaemon; 489 theDaemon = this.isDaemon(); 490 strategy.appendField(locator, this, "daemon", buffer, theDaemon); 491 } 492 { 493 Boolean theDedicatedTaskRunner; 494 theDedicatedTaskRunner = this.isDedicatedTaskRunner(); 495 strategy.appendField(locator, this, "dedicatedTaskRunner", buffer, theDedicatedTaskRunner); 496 } 497 { 498 String theExecutor; 499 theExecutor = this.getExecutor(); 500 strategy.appendField(locator, this, "executor", buffer, theExecutor); 501 } 502 { 503 BigInteger theMaxIterationsPerRun; 504 theMaxIterationsPerRun = this.getMaxIterationsPerRun(); 505 strategy.appendField(locator, this, "maxIterationsPerRun", buffer, theMaxIterationsPerRun); 506 } 507 { 508 BigInteger theMaxThreadPoolSize; 509 theMaxThreadPoolSize = this.getMaxThreadPoolSize(); 510 strategy.appendField(locator, this, "maxThreadPoolSize", buffer, theMaxThreadPoolSize); 511 } 512 { 513 String theName; 514 theName = this.getName(); 515 strategy.appendField(locator, this, "name", buffer, theName); 516 } 517 { 518 BigInteger thePriority; 519 thePriority = this.getPriority(); 520 strategy.appendField(locator, this, "priority", buffer, thePriority); 521 } 522 { 523 String theRejectedTaskHandler; 524 theRejectedTaskHandler = this.getRejectedTaskHandler(); 525 strategy.appendField(locator, this, "rejectedTaskHandler", buffer, theRejectedTaskHandler); 526 } 527 { 528 Long theShutdownAwaitTermination; 529 theShutdownAwaitTermination = this.getShutdownAwaitTermination(); 530 strategy.appendField(locator, this, "shutdownAwaitTermination", buffer, theShutdownAwaitTermination); 531 } 532 { 533 String theThreadClassLoader; 534 theThreadClassLoader = this.getThreadClassLoader(); 535 strategy.appendField(locator, this, "threadClassLoader", buffer, theThreadClassLoader); 536 } 537 { 538 String theId; 539 theId = this.getId(); 540 strategy.appendField(locator, this, "id", buffer, theId); 541 } 542 return buffer; 543 } 544 545 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 546 int currentHashCode = 1; 547 { 548 List<Object> theExecutorOrRejectedTaskHandlerOrThreadClassLoader; 549 theExecutorOrRejectedTaskHandlerOrThreadClassLoader = (((this.executorOrRejectedTaskHandlerOrThreadClassLoader!= null)&&(!this.executorOrRejectedTaskHandlerOrThreadClassLoader.isEmpty()))?this.getExecutorOrRejectedTaskHandlerOrThreadClassLoader():null); 550 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "executorOrRejectedTaskHandlerOrThreadClassLoader", theExecutorOrRejectedTaskHandlerOrThreadClassLoader), currentHashCode, theExecutorOrRejectedTaskHandlerOrThreadClassLoader); 551 } 552 { 553 Boolean theDaemon; 554 theDaemon = this.isDaemon(); 555 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "daemon", theDaemon), currentHashCode, theDaemon); 556 } 557 { 558 Boolean theDedicatedTaskRunner; 559 theDedicatedTaskRunner = this.isDedicatedTaskRunner(); 560 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dedicatedTaskRunner", theDedicatedTaskRunner), currentHashCode, theDedicatedTaskRunner); 561 } 562 { 563 String theExecutor; 564 theExecutor = this.getExecutor(); 565 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "executor", theExecutor), currentHashCode, theExecutor); 566 } 567 { 568 BigInteger theMaxIterationsPerRun; 569 theMaxIterationsPerRun = this.getMaxIterationsPerRun(); 570 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxIterationsPerRun", theMaxIterationsPerRun), currentHashCode, theMaxIterationsPerRun); 571 } 572 { 573 BigInteger theMaxThreadPoolSize; 574 theMaxThreadPoolSize = this.getMaxThreadPoolSize(); 575 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxThreadPoolSize", theMaxThreadPoolSize), currentHashCode, theMaxThreadPoolSize); 576 } 577 { 578 String theName; 579 theName = this.getName(); 580 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "name", theName), currentHashCode, theName); 581 } 582 { 583 BigInteger thePriority; 584 thePriority = this.getPriority(); 585 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "priority", thePriority), currentHashCode, thePriority); 586 } 587 { 588 String theRejectedTaskHandler; 589 theRejectedTaskHandler = this.getRejectedTaskHandler(); 590 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "rejectedTaskHandler", theRejectedTaskHandler), currentHashCode, theRejectedTaskHandler); 591 } 592 { 593 Long theShutdownAwaitTermination; 594 theShutdownAwaitTermination = this.getShutdownAwaitTermination(); 595 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "shutdownAwaitTermination", theShutdownAwaitTermination), currentHashCode, theShutdownAwaitTermination); 596 } 597 { 598 String theThreadClassLoader; 599 theThreadClassLoader = this.getThreadClassLoader(); 600 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "threadClassLoader", theThreadClassLoader), currentHashCode, theThreadClassLoader); 601 } 602 { 603 String theId; 604 theId = this.getId(); 605 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 606 } 607 return currentHashCode; 608 } 609 610 public int hashCode() { 611 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 612 return this.hashCode(null, strategy); 613 } 614 615 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 616 if (!(object instanceof DtoTaskRunnerFactory)) { 617 return false; 618 } 619 if (this == object) { 620 return true; 621 } 622 final DtoTaskRunnerFactory that = ((DtoTaskRunnerFactory) object); 623 { 624 List<Object> lhsExecutorOrRejectedTaskHandlerOrThreadClassLoader; 625 lhsExecutorOrRejectedTaskHandlerOrThreadClassLoader = (((this.executorOrRejectedTaskHandlerOrThreadClassLoader!= null)&&(!this.executorOrRejectedTaskHandlerOrThreadClassLoader.isEmpty()))?this.getExecutorOrRejectedTaskHandlerOrThreadClassLoader():null); 626 List<Object> rhsExecutorOrRejectedTaskHandlerOrThreadClassLoader; 627 rhsExecutorOrRejectedTaskHandlerOrThreadClassLoader = (((that.executorOrRejectedTaskHandlerOrThreadClassLoader!= null)&&(!that.executorOrRejectedTaskHandlerOrThreadClassLoader.isEmpty()))?that.getExecutorOrRejectedTaskHandlerOrThreadClassLoader():null); 628 if (!strategy.equals(LocatorUtils.property(thisLocator, "executorOrRejectedTaskHandlerOrThreadClassLoader", lhsExecutorOrRejectedTaskHandlerOrThreadClassLoader), LocatorUtils.property(thatLocator, "executorOrRejectedTaskHandlerOrThreadClassLoader", rhsExecutorOrRejectedTaskHandlerOrThreadClassLoader), lhsExecutorOrRejectedTaskHandlerOrThreadClassLoader, rhsExecutorOrRejectedTaskHandlerOrThreadClassLoader)) { 629 return false; 630 } 631 } 632 { 633 Boolean lhsDaemon; 634 lhsDaemon = this.isDaemon(); 635 Boolean rhsDaemon; 636 rhsDaemon = that.isDaemon(); 637 if (!strategy.equals(LocatorUtils.property(thisLocator, "daemon", lhsDaemon), LocatorUtils.property(thatLocator, "daemon", rhsDaemon), lhsDaemon, rhsDaemon)) { 638 return false; 639 } 640 } 641 { 642 Boolean lhsDedicatedTaskRunner; 643 lhsDedicatedTaskRunner = this.isDedicatedTaskRunner(); 644 Boolean rhsDedicatedTaskRunner; 645 rhsDedicatedTaskRunner = that.isDedicatedTaskRunner(); 646 if (!strategy.equals(LocatorUtils.property(thisLocator, "dedicatedTaskRunner", lhsDedicatedTaskRunner), LocatorUtils.property(thatLocator, "dedicatedTaskRunner", rhsDedicatedTaskRunner), lhsDedicatedTaskRunner, rhsDedicatedTaskRunner)) { 647 return false; 648 } 649 } 650 { 651 String lhsExecutor; 652 lhsExecutor = this.getExecutor(); 653 String rhsExecutor; 654 rhsExecutor = that.getExecutor(); 655 if (!strategy.equals(LocatorUtils.property(thisLocator, "executor", lhsExecutor), LocatorUtils.property(thatLocator, "executor", rhsExecutor), lhsExecutor, rhsExecutor)) { 656 return false; 657 } 658 } 659 { 660 BigInteger lhsMaxIterationsPerRun; 661 lhsMaxIterationsPerRun = this.getMaxIterationsPerRun(); 662 BigInteger rhsMaxIterationsPerRun; 663 rhsMaxIterationsPerRun = that.getMaxIterationsPerRun(); 664 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxIterationsPerRun", lhsMaxIterationsPerRun), LocatorUtils.property(thatLocator, "maxIterationsPerRun", rhsMaxIterationsPerRun), lhsMaxIterationsPerRun, rhsMaxIterationsPerRun)) { 665 return false; 666 } 667 } 668 { 669 BigInteger lhsMaxThreadPoolSize; 670 lhsMaxThreadPoolSize = this.getMaxThreadPoolSize(); 671 BigInteger rhsMaxThreadPoolSize; 672 rhsMaxThreadPoolSize = that.getMaxThreadPoolSize(); 673 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxThreadPoolSize", lhsMaxThreadPoolSize), LocatorUtils.property(thatLocator, "maxThreadPoolSize", rhsMaxThreadPoolSize), lhsMaxThreadPoolSize, rhsMaxThreadPoolSize)) { 674 return false; 675 } 676 } 677 { 678 String lhsName; 679 lhsName = this.getName(); 680 String rhsName; 681 rhsName = that.getName(); 682 if (!strategy.equals(LocatorUtils.property(thisLocator, "name", lhsName), LocatorUtils.property(thatLocator, "name", rhsName), lhsName, rhsName)) { 683 return false; 684 } 685 } 686 { 687 BigInteger lhsPriority; 688 lhsPriority = this.getPriority(); 689 BigInteger rhsPriority; 690 rhsPriority = that.getPriority(); 691 if (!strategy.equals(LocatorUtils.property(thisLocator, "priority", lhsPriority), LocatorUtils.property(thatLocator, "priority", rhsPriority), lhsPriority, rhsPriority)) { 692 return false; 693 } 694 } 695 { 696 String lhsRejectedTaskHandler; 697 lhsRejectedTaskHandler = this.getRejectedTaskHandler(); 698 String rhsRejectedTaskHandler; 699 rhsRejectedTaskHandler = that.getRejectedTaskHandler(); 700 if (!strategy.equals(LocatorUtils.property(thisLocator, "rejectedTaskHandler", lhsRejectedTaskHandler), LocatorUtils.property(thatLocator, "rejectedTaskHandler", rhsRejectedTaskHandler), lhsRejectedTaskHandler, rhsRejectedTaskHandler)) { 701 return false; 702 } 703 } 704 { 705 Long lhsShutdownAwaitTermination; 706 lhsShutdownAwaitTermination = this.getShutdownAwaitTermination(); 707 Long rhsShutdownAwaitTermination; 708 rhsShutdownAwaitTermination = that.getShutdownAwaitTermination(); 709 if (!strategy.equals(LocatorUtils.property(thisLocator, "shutdownAwaitTermination", lhsShutdownAwaitTermination), LocatorUtils.property(thatLocator, "shutdownAwaitTermination", rhsShutdownAwaitTermination), lhsShutdownAwaitTermination, rhsShutdownAwaitTermination)) { 710 return false; 711 } 712 } 713 { 714 String lhsThreadClassLoader; 715 lhsThreadClassLoader = this.getThreadClassLoader(); 716 String rhsThreadClassLoader; 717 rhsThreadClassLoader = that.getThreadClassLoader(); 718 if (!strategy.equals(LocatorUtils.property(thisLocator, "threadClassLoader", lhsThreadClassLoader), LocatorUtils.property(thatLocator, "threadClassLoader", rhsThreadClassLoader), lhsThreadClassLoader, rhsThreadClassLoader)) { 719 return false; 720 } 721 } 722 { 723 String lhsId; 724 lhsId = this.getId(); 725 String rhsId; 726 rhsId = that.getId(); 727 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 728 return false; 729 } 730 } 731 return true; 732 } 733 734 public boolean equals(Object object) { 735 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 736 return equals(null, null, object, strategy); 737 } 738 739 740 /** 741 * <p>Java class for anonymous complex type. 742 * 743 * <p>The following schema fragment specifies the expected content contained within this class. 744 * 745 * <pre> 746 * <complexType> 747 * <complexContent> 748 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 749 * <sequence minOccurs="0"> 750 * <any maxOccurs="unbounded" minOccurs="0"/> 751 * </sequence> 752 * </restriction> 753 * </complexContent> 754 * </complexType> 755 * </pre> 756 * 757 * 758 */ 759 @XmlAccessorType(XmlAccessType.FIELD) 760 @XmlType(name = "", propOrder = { 761 "any" 762 }) 763 public static class Executor 764 implements Equals, HashCode, ToString 765 { 766 767 @XmlAnyElement(lax = true) 768 protected List<Object> any; 769 770 /** 771 * Gets the value of the any property. 772 * 773 * <p> 774 * This accessor method returns a reference to the live list, 775 * not a snapshot. Therefore any modification you make to the 776 * returned list will be present inside the JAXB object. 777 * This is why there is not a <CODE>set</CODE> method for the any property. 778 * 779 * <p> 780 * For example, to add a new item, do as follows: 781 * <pre> 782 * getAny().add(newItem); 783 * </pre> 784 * 785 * 786 * <p> 787 * Objects of the following type(s) are allowed in the list 788 * {@link Object } 789 * 790 * 791 */ 792 public List<Object> getAny() { 793 if (any == null) { 794 any = new ArrayList<Object>(); 795 } 796 return this.any; 797 } 798 799 public String toString() { 800 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 801 final StringBuilder buffer = new StringBuilder(); 802 append(null, buffer, strategy); 803 return buffer.toString(); 804 } 805 806 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 807 strategy.appendStart(locator, this, buffer); 808 appendFields(locator, buffer, strategy); 809 strategy.appendEnd(locator, this, buffer); 810 return buffer; 811 } 812 813 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 814 { 815 List<Object> theAny; 816 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 817 strategy.appendField(locator, this, "any", buffer, theAny); 818 } 819 return buffer; 820 } 821 822 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 823 int currentHashCode = 1; 824 { 825 List<Object> theAny; 826 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 827 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 828 } 829 return currentHashCode; 830 } 831 832 public int hashCode() { 833 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 834 return this.hashCode(null, strategy); 835 } 836 837 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 838 if (!(object instanceof DtoTaskRunnerFactory.Executor)) { 839 return false; 840 } 841 if (this == object) { 842 return true; 843 } 844 final DtoTaskRunnerFactory.Executor that = ((DtoTaskRunnerFactory.Executor) object); 845 { 846 List<Object> lhsAny; 847 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 848 List<Object> rhsAny; 849 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 850 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 851 return false; 852 } 853 } 854 return true; 855 } 856 857 public boolean equals(Object object) { 858 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 859 return equals(null, null, object, strategy); 860 } 861 862 } 863 864 865 /** 866 * <p>Java class for anonymous complex type. 867 * 868 * <p>The following schema fragment specifies the expected content contained within this class. 869 * 870 * <pre> 871 * <complexType> 872 * <complexContent> 873 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 874 * <sequence minOccurs="0"> 875 * <any maxOccurs="unbounded" minOccurs="0"/> 876 * </sequence> 877 * </restriction> 878 * </complexContent> 879 * </complexType> 880 * </pre> 881 * 882 * 883 */ 884 @XmlAccessorType(XmlAccessType.FIELD) 885 @XmlType(name = "", propOrder = { 886 "any" 887 }) 888 public static class RejectedTaskHandler 889 implements Equals, HashCode, ToString 890 { 891 892 @XmlAnyElement(lax = true) 893 protected List<Object> any; 894 895 /** 896 * Gets the value of the any property. 897 * 898 * <p> 899 * This accessor method returns a reference to the live list, 900 * not a snapshot. Therefore any modification you make to the 901 * returned list will be present inside the JAXB object. 902 * This is why there is not a <CODE>set</CODE> method for the any property. 903 * 904 * <p> 905 * For example, to add a new item, do as follows: 906 * <pre> 907 * getAny().add(newItem); 908 * </pre> 909 * 910 * 911 * <p> 912 * Objects of the following type(s) are allowed in the list 913 * {@link Object } 914 * 915 * 916 */ 917 public List<Object> getAny() { 918 if (any == null) { 919 any = new ArrayList<Object>(); 920 } 921 return this.any; 922 } 923 924 public String toString() { 925 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 926 final StringBuilder buffer = new StringBuilder(); 927 append(null, buffer, strategy); 928 return buffer.toString(); 929 } 930 931 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 932 strategy.appendStart(locator, this, buffer); 933 appendFields(locator, buffer, strategy); 934 strategy.appendEnd(locator, this, buffer); 935 return buffer; 936 } 937 938 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 939 { 940 List<Object> theAny; 941 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 942 strategy.appendField(locator, this, "any", buffer, theAny); 943 } 944 return buffer; 945 } 946 947 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 948 int currentHashCode = 1; 949 { 950 List<Object> theAny; 951 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 952 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 953 } 954 return currentHashCode; 955 } 956 957 public int hashCode() { 958 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 959 return this.hashCode(null, strategy); 960 } 961 962 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 963 if (!(object instanceof DtoTaskRunnerFactory.RejectedTaskHandler)) { 964 return false; 965 } 966 if (this == object) { 967 return true; 968 } 969 final DtoTaskRunnerFactory.RejectedTaskHandler that = ((DtoTaskRunnerFactory.RejectedTaskHandler) object); 970 { 971 List<Object> lhsAny; 972 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 973 List<Object> rhsAny; 974 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 975 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 976 return false; 977 } 978 } 979 return true; 980 } 981 982 public boolean equals(Object object) { 983 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 984 return equals(null, null, object, strategy); 985 } 986 987 } 988 989 990 /** 991 * <p>Java class for anonymous complex type. 992 * 993 * <p>The following schema fragment specifies the expected content contained within this class. 994 * 995 * <pre> 996 * <complexType> 997 * <complexContent> 998 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 999 * <sequence minOccurs="0"> 1000 * <any maxOccurs="unbounded" minOccurs="0"/> 1001 * </sequence> 1002 * </restriction> 1003 * </complexContent> 1004 * </complexType> 1005 * </pre> 1006 * 1007 * 1008 */ 1009 @XmlAccessorType(XmlAccessType.FIELD) 1010 @XmlType(name = "", propOrder = { 1011 "any" 1012 }) 1013 public static class ThreadClassLoader 1014 implements Equals, HashCode, ToString 1015 { 1016 1017 @XmlAnyElement(lax = true) 1018 protected List<Object> any; 1019 1020 /** 1021 * Gets the value of the any property. 1022 * 1023 * <p> 1024 * This accessor method returns a reference to the live list, 1025 * not a snapshot. Therefore any modification you make to the 1026 * returned list will be present inside the JAXB object. 1027 * This is why there is not a <CODE>set</CODE> method for the any property. 1028 * 1029 * <p> 1030 * For example, to add a new item, do as follows: 1031 * <pre> 1032 * getAny().add(newItem); 1033 * </pre> 1034 * 1035 * 1036 * <p> 1037 * Objects of the following type(s) are allowed in the list 1038 * {@link Object } 1039 * 1040 * 1041 */ 1042 public List<Object> getAny() { 1043 if (any == null) { 1044 any = new ArrayList<Object>(); 1045 } 1046 return this.any; 1047 } 1048 1049 public String toString() { 1050 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1051 final StringBuilder buffer = new StringBuilder(); 1052 append(null, buffer, strategy); 1053 return buffer.toString(); 1054 } 1055 1056 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1057 strategy.appendStart(locator, this, buffer); 1058 appendFields(locator, buffer, strategy); 1059 strategy.appendEnd(locator, this, buffer); 1060 return buffer; 1061 } 1062 1063 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1064 { 1065 List<Object> theAny; 1066 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1067 strategy.appendField(locator, this, "any", buffer, theAny); 1068 } 1069 return buffer; 1070 } 1071 1072 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1073 int currentHashCode = 1; 1074 { 1075 List<Object> theAny; 1076 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1077 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1078 } 1079 return currentHashCode; 1080 } 1081 1082 public int hashCode() { 1083 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1084 return this.hashCode(null, strategy); 1085 } 1086 1087 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1088 if (!(object instanceof DtoTaskRunnerFactory.ThreadClassLoader)) { 1089 return false; 1090 } 1091 if (this == object) { 1092 return true; 1093 } 1094 final DtoTaskRunnerFactory.ThreadClassLoader that = ((DtoTaskRunnerFactory.ThreadClassLoader) object); 1095 { 1096 List<Object> lhsAny; 1097 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1098 List<Object> rhsAny; 1099 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 1100 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1101 return false; 1102 } 1103 } 1104 return true; 1105 } 1106 1107 public boolean equals(Object object) { 1108 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1109 return equals(null, null, object, strategy); 1110 } 1111 1112 } 1113 1114}