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