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: 2015.08.06 at 10:20:24 AM 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.XmlElement; 023import javax.xml.bind.annotation.XmlElementRef; 024import javax.xml.bind.annotation.XmlElementRefs; 025import javax.xml.bind.annotation.XmlID; 026import javax.xml.bind.annotation.XmlRootElement; 027import javax.xml.bind.annotation.XmlSchemaType; 028import javax.xml.bind.annotation.XmlType; 029import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; 030import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 031import javax.xml.namespace.QName; 032import org.jvnet.jaxb2_commons.lang.Equals; 033import org.jvnet.jaxb2_commons.lang.EqualsStrategy; 034import org.jvnet.jaxb2_commons.lang.HashCode; 035import org.jvnet.jaxb2_commons.lang.HashCodeStrategy; 036import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy; 037import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; 038import org.jvnet.jaxb2_commons.lang.ToString; 039import org.jvnet.jaxb2_commons.lang.ToStringStrategy; 040import org.jvnet.jaxb2_commons.locator.ObjectLocator; 041import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; 042 043 044/** 045 * <p>Java class for anonymous complex type. 046 * 047 * <p>The following schema fragment specifies the expected content contained within this class. 048 * 049 * <pre> 050 * <complexType> 051 * <complexContent> 052 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 053 * <choice maxOccurs="unbounded" minOccurs="0"> 054 * <choice> 055 * <element name="brokerService" minOccurs="0"> 056 * <complexType> 057 * <complexContent> 058 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 059 * <choice minOccurs="0"> 060 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 061 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 062 * <any namespace='##other'/> 063 * </choice> 064 * </restriction> 065 * </complexContent> 066 * </complexType> 067 * </element> 068 * <element name="locker" minOccurs="0"> 069 * <complexType> 070 * <complexContent> 071 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 072 * <choice minOccurs="0"> 073 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 074 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 075 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 076 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 077 * <any namespace='##other'/> 078 * </choice> 079 * </restriction> 080 * </complexContent> 081 * </complexType> 082 * </element> 083 * <element name="scheduledThreadPoolExecutor" minOccurs="0"> 084 * <complexType> 085 * <complexContent> 086 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 087 * <sequence minOccurs="0"> 088 * <any maxOccurs="unbounded" minOccurs="0"/> 089 * </sequence> 090 * </restriction> 091 * </complexContent> 092 * </complexType> 093 * </element> 094 * <element name="transactionIdTransformer" minOccurs="0"> 095 * <complexType> 096 * <complexContent> 097 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 098 * <sequence minOccurs="0"> 099 * <any maxOccurs="unbounded" minOccurs="0"/> 100 * </sequence> 101 * </restriction> 102 * </complexContent> 103 * </complexType> 104 * </element> 105 * <element name="usageManager" minOccurs="0"> 106 * <complexType> 107 * <complexContent> 108 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 109 * <choice minOccurs="0"> 110 * <element ref="{http://activemq.apache.org/schema/core}systemUsage"/> 111 * <any namespace='##other'/> 112 * </choice> 113 * </restriction> 114 * </complexContent> 115 * </complexType> 116 * </element> 117 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 118 * </choice> 119 * </choice> 120 * <attribute name="archiveCorruptedIndex" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 121 * <attribute name="archiveDataLogs" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 122 * <attribute name="brokerName" type="{http://www.w3.org/2001/XMLSchema}string" /> 123 * <attribute name="brokerService" type="{http://www.w3.org/2001/XMLSchema}string" /> 124 * <attribute name="checkForCorruptJournalFiles" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 125 * <attribute name="checkpointInterval" type="{http://www.w3.org/2001/XMLSchema}long" /> 126 * <attribute name="checksumJournalFiles" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 127 * <attribute name="cleanupInterval" type="{http://www.w3.org/2001/XMLSchema}long" /> 128 * <attribute name="concurrentStoreAndDispatchQueues" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 129 * <attribute name="concurrentStoreAndDispatchTopics" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 130 * <attribute name="databaseLockedWaitDelay" type="{http://www.w3.org/2001/XMLSchema}integer" /> 131 * <attribute name="directory" type="{http://www.w3.org/2001/XMLSchema}string" /> 132 * <attribute name="directoryArchive" type="{http://www.w3.org/2001/XMLSchema}string" /> 133 * <attribute name="enableIndexDiskSyncs" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 134 * <attribute name="enableIndexPageCaching" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 135 * <attribute name="enableIndexRecoveryFile" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 136 * <attribute name="enableIndexWriteAsync" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 137 * <attribute name="enableJournalDiskSyncs" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 138 * <attribute name="failoverProducersAuditDepth" type="{http://www.w3.org/2001/XMLSchema}integer" /> 139 * <attribute name="forceRecoverIndex" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 140 * <attribute name="ignoreMissingJournalfiles" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 141 * <attribute name="indexCacheSize" type="{http://www.w3.org/2001/XMLSchema}string" /> 142 * <attribute name="indexDirectory" type="{http://www.w3.org/2001/XMLSchema}string" /> 143 * <attribute name="indexLFUEvictionFactor" type="{http://www.w3.org/2001/XMLSchema}float" /> 144 * <attribute name="indexWriteBatchSize" type="{http://www.w3.org/2001/XMLSchema}string" /> 145 * <attribute name="journalMaxFileLength" type="{http://www.w3.org/2001/XMLSchema}string" /> 146 * <attribute name="journalMaxWriteBatchSize" type="{http://www.w3.org/2001/XMLSchema}string" /> 147 * <attribute name="lockKeepAlivePeriod" type="{http://www.w3.org/2001/XMLSchema}long" /> 148 * <attribute name="locker" type="{http://www.w3.org/2001/XMLSchema}string" /> 149 * <attribute name="maxAsyncJobs" type="{http://www.w3.org/2001/XMLSchema}integer" /> 150 * <attribute name="maxFailoverProducersToTrack" type="{http://www.w3.org/2001/XMLSchema}integer" /> 151 * <attribute name="scheduledThreadPoolExecutor" type="{http://www.w3.org/2001/XMLSchema}string" /> 152 * <attribute name="transactionIdTransformer" type="{http://www.w3.org/2001/XMLSchema}string" /> 153 * <attribute name="usageManager" type="{http://www.w3.org/2001/XMLSchema}string" /> 154 * <attribute name="useIndexLFRUEviction" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 155 * <attribute name="useLock" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 156 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 157 * <anyAttribute processContents='lax' namespace='##other'/> 158 * </restriction> 159 * </complexContent> 160 * </complexType> 161 * </pre> 162 * 163 * 164 */ 165@XmlAccessorType(XmlAccessType.FIELD) 166@XmlType(name = "", propOrder = { 167 "brokerServiceOrLockerOrScheduledThreadPoolExecutor" 168}) 169@XmlRootElement(name = "kahaDB") 170public class DtoKahaDB implements Equals, HashCode, ToString 171{ 172 173 @XmlElementRefs({ 174 @XmlElementRef(name = "locker", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 175 @XmlElementRef(name = "transactionIdTransformer", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 176 @XmlElementRef(name = "brokerService", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 177 @XmlElementRef(name = "usageManager", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 178 @XmlElementRef(name = "scheduledThreadPoolExecutor", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 179 }) 180 @XmlAnyElement(lax = true) 181 protected List<Object> brokerServiceOrLockerOrScheduledThreadPoolExecutor; 182 @XmlAttribute(name = "archiveCorruptedIndex") 183 protected Boolean archiveCorruptedIndex; 184 @XmlAttribute(name = "archiveDataLogs") 185 protected Boolean archiveDataLogs; 186 @XmlAttribute(name = "brokerName") 187 protected String brokerName; 188 @XmlAttribute(name = "brokerService") 189 protected String brokerService; 190 @XmlAttribute(name = "checkForCorruptJournalFiles") 191 protected Boolean checkForCorruptJournalFiles; 192 @XmlAttribute(name = "checkpointInterval") 193 protected Long checkpointInterval; 194 @XmlAttribute(name = "checksumJournalFiles") 195 protected Boolean checksumJournalFiles; 196 @XmlAttribute(name = "cleanupInterval") 197 protected Long cleanupInterval; 198 @XmlAttribute(name = "concurrentStoreAndDispatchQueues") 199 protected Boolean concurrentStoreAndDispatchQueues; 200 @XmlAttribute(name = "concurrentStoreAndDispatchTopics") 201 protected Boolean concurrentStoreAndDispatchTopics; 202 @XmlAttribute(name = "databaseLockedWaitDelay") 203 protected BigInteger databaseLockedWaitDelay; 204 @XmlAttribute(name = "directory") 205 protected String directory; 206 @XmlAttribute(name = "directoryArchive") 207 protected String directoryArchive; 208 @XmlAttribute(name = "enableIndexDiskSyncs") 209 protected Boolean enableIndexDiskSyncs; 210 @XmlAttribute(name = "enableIndexPageCaching") 211 protected Boolean enableIndexPageCaching; 212 @XmlAttribute(name = "enableIndexRecoveryFile") 213 protected Boolean enableIndexRecoveryFile; 214 @XmlAttribute(name = "enableIndexWriteAsync") 215 protected Boolean enableIndexWriteAsync; 216 @XmlAttribute(name = "enableJournalDiskSyncs") 217 protected Boolean enableJournalDiskSyncs; 218 @XmlAttribute(name = "failoverProducersAuditDepth") 219 protected BigInteger failoverProducersAuditDepth; 220 @XmlAttribute(name = "forceRecoverIndex") 221 protected Boolean forceRecoverIndex; 222 @XmlAttribute(name = "ignoreMissingJournalfiles") 223 protected Boolean ignoreMissingJournalfiles; 224 @XmlAttribute(name = "indexCacheSize") 225 protected String indexCacheSize; 226 @XmlAttribute(name = "indexDirectory") 227 protected String indexDirectory; 228 @XmlAttribute(name = "indexLFUEvictionFactor") 229 protected Float indexLFUEvictionFactor; 230 @XmlAttribute(name = "indexWriteBatchSize") 231 protected String indexWriteBatchSize; 232 @XmlAttribute(name = "journalMaxFileLength") 233 protected String journalMaxFileLength; 234 @XmlAttribute(name = "journalMaxWriteBatchSize") 235 protected String journalMaxWriteBatchSize; 236 @XmlAttribute(name = "lockKeepAlivePeriod") 237 protected Long lockKeepAlivePeriod; 238 @XmlAttribute(name = "locker") 239 protected String locker; 240 @XmlAttribute(name = "maxAsyncJobs") 241 protected BigInteger maxAsyncJobs; 242 @XmlAttribute(name = "maxFailoverProducersToTrack") 243 protected BigInteger maxFailoverProducersToTrack; 244 @XmlAttribute(name = "scheduledThreadPoolExecutor") 245 protected String scheduledThreadPoolExecutor; 246 @XmlAttribute(name = "transactionIdTransformer") 247 protected String transactionIdTransformer; 248 @XmlAttribute(name = "usageManager") 249 protected String usageManager; 250 @XmlAttribute(name = "useIndexLFRUEviction") 251 protected Boolean useIndexLFRUEviction; 252 @XmlAttribute(name = "useLock") 253 protected Boolean useLock; 254 @XmlAttribute(name = "id") 255 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 256 @XmlID 257 @XmlSchemaType(name = "ID") 258 protected String id; 259 @XmlAnyAttribute 260 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 261 262 /** 263 * Gets the value of the brokerServiceOrLockerOrScheduledThreadPoolExecutor property. 264 * 265 * <p> 266 * This accessor method returns a reference to the live list, 267 * not a snapshot. Therefore any modification you make to the 268 * returned list will be present inside the JAXB object. 269 * This is why there is not a <CODE>set</CODE> method for the brokerServiceOrLockerOrScheduledThreadPoolExecutor property. 270 * 271 * <p> 272 * For example, to add a new item, do as follows: 273 * <pre> 274 * getBrokerServiceOrLockerOrScheduledThreadPoolExecutor().add(newItem); 275 * </pre> 276 * 277 * 278 * <p> 279 * Objects of the following type(s) are allowed in the list 280 * {@link JAXBElement }{@code <}{@link DtoKahaDB.BrokerService }{@code >} 281 * {@link Object } 282 * {@link JAXBElement }{@code <}{@link DtoKahaDB.UsageManager }{@code >} 283 * {@link JAXBElement }{@code <}{@link DtoKahaDB.ScheduledThreadPoolExecutor }{@code >} 284 * {@link JAXBElement }{@code <}{@link DtoKahaDB.Locker }{@code >} 285 * {@link JAXBElement }{@code <}{@link DtoKahaDB.TransactionIdTransformer }{@code >} 286 * 287 * 288 */ 289 public List<Object> getBrokerServiceOrLockerOrScheduledThreadPoolExecutor() { 290 if (brokerServiceOrLockerOrScheduledThreadPoolExecutor == null) { 291 brokerServiceOrLockerOrScheduledThreadPoolExecutor = new ArrayList<Object>(); 292 } 293 return this.brokerServiceOrLockerOrScheduledThreadPoolExecutor; 294 } 295 296 /** 297 * Gets the value of the archiveCorruptedIndex property. 298 * 299 * @return 300 * possible object is 301 * {@link Boolean } 302 * 303 */ 304 public Boolean isArchiveCorruptedIndex() { 305 return archiveCorruptedIndex; 306 } 307 308 /** 309 * Sets the value of the archiveCorruptedIndex property. 310 * 311 * @param value 312 * allowed object is 313 * {@link Boolean } 314 * 315 */ 316 public void setArchiveCorruptedIndex(Boolean value) { 317 this.archiveCorruptedIndex = value; 318 } 319 320 /** 321 * Gets the value of the archiveDataLogs property. 322 * 323 * @return 324 * possible object is 325 * {@link Boolean } 326 * 327 */ 328 public Boolean isArchiveDataLogs() { 329 return archiveDataLogs; 330 } 331 332 /** 333 * Sets the value of the archiveDataLogs property. 334 * 335 * @param value 336 * allowed object is 337 * {@link Boolean } 338 * 339 */ 340 public void setArchiveDataLogs(Boolean value) { 341 this.archiveDataLogs = value; 342 } 343 344 /** 345 * Gets the value of the brokerName property. 346 * 347 * @return 348 * possible object is 349 * {@link String } 350 * 351 */ 352 public String getBrokerName() { 353 return brokerName; 354 } 355 356 /** 357 * Sets the value of the brokerName property. 358 * 359 * @param value 360 * allowed object is 361 * {@link String } 362 * 363 */ 364 public void setBrokerName(String value) { 365 this.brokerName = value; 366 } 367 368 /** 369 * Gets the value of the brokerService property. 370 * 371 * @return 372 * possible object is 373 * {@link String } 374 * 375 */ 376 public String getBrokerService() { 377 return brokerService; 378 } 379 380 /** 381 * Sets the value of the brokerService property. 382 * 383 * @param value 384 * allowed object is 385 * {@link String } 386 * 387 */ 388 public void setBrokerService(String value) { 389 this.brokerService = value; 390 } 391 392 /** 393 * Gets the value of the checkForCorruptJournalFiles property. 394 * 395 * @return 396 * possible object is 397 * {@link Boolean } 398 * 399 */ 400 public Boolean isCheckForCorruptJournalFiles() { 401 return checkForCorruptJournalFiles; 402 } 403 404 /** 405 * Sets the value of the checkForCorruptJournalFiles property. 406 * 407 * @param value 408 * allowed object is 409 * {@link Boolean } 410 * 411 */ 412 public void setCheckForCorruptJournalFiles(Boolean value) { 413 this.checkForCorruptJournalFiles = value; 414 } 415 416 /** 417 * Gets the value of the checkpointInterval property. 418 * 419 * @return 420 * possible object is 421 * {@link Long } 422 * 423 */ 424 public Long getCheckpointInterval() { 425 return checkpointInterval; 426 } 427 428 /** 429 * Sets the value of the checkpointInterval property. 430 * 431 * @param value 432 * allowed object is 433 * {@link Long } 434 * 435 */ 436 public void setCheckpointInterval(Long value) { 437 this.checkpointInterval = value; 438 } 439 440 /** 441 * Gets the value of the checksumJournalFiles property. 442 * 443 * @return 444 * possible object is 445 * {@link Boolean } 446 * 447 */ 448 public Boolean isChecksumJournalFiles() { 449 return checksumJournalFiles; 450 } 451 452 /** 453 * Sets the value of the checksumJournalFiles property. 454 * 455 * @param value 456 * allowed object is 457 * {@link Boolean } 458 * 459 */ 460 public void setChecksumJournalFiles(Boolean value) { 461 this.checksumJournalFiles = value; 462 } 463 464 /** 465 * Gets the value of the cleanupInterval property. 466 * 467 * @return 468 * possible object is 469 * {@link Long } 470 * 471 */ 472 public Long getCleanupInterval() { 473 return cleanupInterval; 474 } 475 476 /** 477 * Sets the value of the cleanupInterval property. 478 * 479 * @param value 480 * allowed object is 481 * {@link Long } 482 * 483 */ 484 public void setCleanupInterval(Long value) { 485 this.cleanupInterval = value; 486 } 487 488 /** 489 * Gets the value of the concurrentStoreAndDispatchQueues property. 490 * 491 * @return 492 * possible object is 493 * {@link Boolean } 494 * 495 */ 496 public Boolean isConcurrentStoreAndDispatchQueues() { 497 return concurrentStoreAndDispatchQueues; 498 } 499 500 /** 501 * Sets the value of the concurrentStoreAndDispatchQueues property. 502 * 503 * @param value 504 * allowed object is 505 * {@link Boolean } 506 * 507 */ 508 public void setConcurrentStoreAndDispatchQueues(Boolean value) { 509 this.concurrentStoreAndDispatchQueues = value; 510 } 511 512 /** 513 * Gets the value of the concurrentStoreAndDispatchTopics property. 514 * 515 * @return 516 * possible object is 517 * {@link Boolean } 518 * 519 */ 520 public Boolean isConcurrentStoreAndDispatchTopics() { 521 return concurrentStoreAndDispatchTopics; 522 } 523 524 /** 525 * Sets the value of the concurrentStoreAndDispatchTopics property. 526 * 527 * @param value 528 * allowed object is 529 * {@link Boolean } 530 * 531 */ 532 public void setConcurrentStoreAndDispatchTopics(Boolean value) { 533 this.concurrentStoreAndDispatchTopics = value; 534 } 535 536 /** 537 * Gets the value of the databaseLockedWaitDelay property. 538 * 539 * @return 540 * possible object is 541 * {@link BigInteger } 542 * 543 */ 544 public BigInteger getDatabaseLockedWaitDelay() { 545 return databaseLockedWaitDelay; 546 } 547 548 /** 549 * Sets the value of the databaseLockedWaitDelay property. 550 * 551 * @param value 552 * allowed object is 553 * {@link BigInteger } 554 * 555 */ 556 public void setDatabaseLockedWaitDelay(BigInteger value) { 557 this.databaseLockedWaitDelay = value; 558 } 559 560 /** 561 * Gets the value of the directory property. 562 * 563 * @return 564 * possible object is 565 * {@link String } 566 * 567 */ 568 public String getDirectory() { 569 return directory; 570 } 571 572 /** 573 * Sets the value of the directory property. 574 * 575 * @param value 576 * allowed object is 577 * {@link String } 578 * 579 */ 580 public void setDirectory(String value) { 581 this.directory = value; 582 } 583 584 /** 585 * Gets the value of the directoryArchive property. 586 * 587 * @return 588 * possible object is 589 * {@link String } 590 * 591 */ 592 public String getDirectoryArchive() { 593 return directoryArchive; 594 } 595 596 /** 597 * Sets the value of the directoryArchive property. 598 * 599 * @param value 600 * allowed object is 601 * {@link String } 602 * 603 */ 604 public void setDirectoryArchive(String value) { 605 this.directoryArchive = value; 606 } 607 608 /** 609 * Gets the value of the enableIndexDiskSyncs property. 610 * 611 * @return 612 * possible object is 613 * {@link Boolean } 614 * 615 */ 616 public Boolean isEnableIndexDiskSyncs() { 617 return enableIndexDiskSyncs; 618 } 619 620 /** 621 * Sets the value of the enableIndexDiskSyncs property. 622 * 623 * @param value 624 * allowed object is 625 * {@link Boolean } 626 * 627 */ 628 public void setEnableIndexDiskSyncs(Boolean value) { 629 this.enableIndexDiskSyncs = value; 630 } 631 632 /** 633 * Gets the value of the enableIndexPageCaching property. 634 * 635 * @return 636 * possible object is 637 * {@link Boolean } 638 * 639 */ 640 public Boolean isEnableIndexPageCaching() { 641 return enableIndexPageCaching; 642 } 643 644 /** 645 * Sets the value of the enableIndexPageCaching property. 646 * 647 * @param value 648 * allowed object is 649 * {@link Boolean } 650 * 651 */ 652 public void setEnableIndexPageCaching(Boolean value) { 653 this.enableIndexPageCaching = value; 654 } 655 656 /** 657 * Gets the value of the enableIndexRecoveryFile property. 658 * 659 * @return 660 * possible object is 661 * {@link Boolean } 662 * 663 */ 664 public Boolean isEnableIndexRecoveryFile() { 665 return enableIndexRecoveryFile; 666 } 667 668 /** 669 * Sets the value of the enableIndexRecoveryFile property. 670 * 671 * @param value 672 * allowed object is 673 * {@link Boolean } 674 * 675 */ 676 public void setEnableIndexRecoveryFile(Boolean value) { 677 this.enableIndexRecoveryFile = value; 678 } 679 680 /** 681 * Gets the value of the enableIndexWriteAsync property. 682 * 683 * @return 684 * possible object is 685 * {@link Boolean } 686 * 687 */ 688 public Boolean isEnableIndexWriteAsync() { 689 return enableIndexWriteAsync; 690 } 691 692 /** 693 * Sets the value of the enableIndexWriteAsync property. 694 * 695 * @param value 696 * allowed object is 697 * {@link Boolean } 698 * 699 */ 700 public void setEnableIndexWriteAsync(Boolean value) { 701 this.enableIndexWriteAsync = value; 702 } 703 704 /** 705 * Gets the value of the enableJournalDiskSyncs property. 706 * 707 * @return 708 * possible object is 709 * {@link Boolean } 710 * 711 */ 712 public Boolean isEnableJournalDiskSyncs() { 713 return enableJournalDiskSyncs; 714 } 715 716 /** 717 * Sets the value of the enableJournalDiskSyncs property. 718 * 719 * @param value 720 * allowed object is 721 * {@link Boolean } 722 * 723 */ 724 public void setEnableJournalDiskSyncs(Boolean value) { 725 this.enableJournalDiskSyncs = value; 726 } 727 728 /** 729 * Gets the value of the failoverProducersAuditDepth property. 730 * 731 * @return 732 * possible object is 733 * {@link BigInteger } 734 * 735 */ 736 public BigInteger getFailoverProducersAuditDepth() { 737 return failoverProducersAuditDepth; 738 } 739 740 /** 741 * Sets the value of the failoverProducersAuditDepth property. 742 * 743 * @param value 744 * allowed object is 745 * {@link BigInteger } 746 * 747 */ 748 public void setFailoverProducersAuditDepth(BigInteger value) { 749 this.failoverProducersAuditDepth = value; 750 } 751 752 /** 753 * Gets the value of the forceRecoverIndex property. 754 * 755 * @return 756 * possible object is 757 * {@link Boolean } 758 * 759 */ 760 public Boolean isForceRecoverIndex() { 761 return forceRecoverIndex; 762 } 763 764 /** 765 * Sets the value of the forceRecoverIndex property. 766 * 767 * @param value 768 * allowed object is 769 * {@link Boolean } 770 * 771 */ 772 public void setForceRecoverIndex(Boolean value) { 773 this.forceRecoverIndex = value; 774 } 775 776 /** 777 * Gets the value of the ignoreMissingJournalfiles property. 778 * 779 * @return 780 * possible object is 781 * {@link Boolean } 782 * 783 */ 784 public Boolean isIgnoreMissingJournalfiles() { 785 return ignoreMissingJournalfiles; 786 } 787 788 /** 789 * Sets the value of the ignoreMissingJournalfiles property. 790 * 791 * @param value 792 * allowed object is 793 * {@link Boolean } 794 * 795 */ 796 public void setIgnoreMissingJournalfiles(Boolean value) { 797 this.ignoreMissingJournalfiles = value; 798 } 799 800 /** 801 * Gets the value of the indexCacheSize property. 802 * 803 * @return 804 * possible object is 805 * {@link String } 806 * 807 */ 808 public String getIndexCacheSize() { 809 return indexCacheSize; 810 } 811 812 /** 813 * Sets the value of the indexCacheSize property. 814 * 815 * @param value 816 * allowed object is 817 * {@link String } 818 * 819 */ 820 public void setIndexCacheSize(String value) { 821 this.indexCacheSize = value; 822 } 823 824 /** 825 * Gets the value of the indexDirectory property. 826 * 827 * @return 828 * possible object is 829 * {@link String } 830 * 831 */ 832 public String getIndexDirectory() { 833 return indexDirectory; 834 } 835 836 /** 837 * Sets the value of the indexDirectory property. 838 * 839 * @param value 840 * allowed object is 841 * {@link String } 842 * 843 */ 844 public void setIndexDirectory(String value) { 845 this.indexDirectory = value; 846 } 847 848 /** 849 * Gets the value of the indexLFUEvictionFactor property. 850 * 851 * @return 852 * possible object is 853 * {@link Float } 854 * 855 */ 856 public Float getIndexLFUEvictionFactor() { 857 return indexLFUEvictionFactor; 858 } 859 860 /** 861 * Sets the value of the indexLFUEvictionFactor property. 862 * 863 * @param value 864 * allowed object is 865 * {@link Float } 866 * 867 */ 868 public void setIndexLFUEvictionFactor(Float value) { 869 this.indexLFUEvictionFactor = value; 870 } 871 872 /** 873 * Gets the value of the indexWriteBatchSize property. 874 * 875 * @return 876 * possible object is 877 * {@link String } 878 * 879 */ 880 public String getIndexWriteBatchSize() { 881 return indexWriteBatchSize; 882 } 883 884 /** 885 * Sets the value of the indexWriteBatchSize property. 886 * 887 * @param value 888 * allowed object is 889 * {@link String } 890 * 891 */ 892 public void setIndexWriteBatchSize(String value) { 893 this.indexWriteBatchSize = value; 894 } 895 896 /** 897 * Gets the value of the journalMaxFileLength property. 898 * 899 * @return 900 * possible object is 901 * {@link String } 902 * 903 */ 904 public String getJournalMaxFileLength() { 905 return journalMaxFileLength; 906 } 907 908 /** 909 * Sets the value of the journalMaxFileLength property. 910 * 911 * @param value 912 * allowed object is 913 * {@link String } 914 * 915 */ 916 public void setJournalMaxFileLength(String value) { 917 this.journalMaxFileLength = value; 918 } 919 920 /** 921 * Gets the value of the journalMaxWriteBatchSize property. 922 * 923 * @return 924 * possible object is 925 * {@link String } 926 * 927 */ 928 public String getJournalMaxWriteBatchSize() { 929 return journalMaxWriteBatchSize; 930 } 931 932 /** 933 * Sets the value of the journalMaxWriteBatchSize property. 934 * 935 * @param value 936 * allowed object is 937 * {@link String } 938 * 939 */ 940 public void setJournalMaxWriteBatchSize(String value) { 941 this.journalMaxWriteBatchSize = value; 942 } 943 944 /** 945 * Gets the value of the lockKeepAlivePeriod property. 946 * 947 * @return 948 * possible object is 949 * {@link Long } 950 * 951 */ 952 public Long getLockKeepAlivePeriod() { 953 return lockKeepAlivePeriod; 954 } 955 956 /** 957 * Sets the value of the lockKeepAlivePeriod property. 958 * 959 * @param value 960 * allowed object is 961 * {@link Long } 962 * 963 */ 964 public void setLockKeepAlivePeriod(Long value) { 965 this.lockKeepAlivePeriod = value; 966 } 967 968 /** 969 * Gets the value of the locker property. 970 * 971 * @return 972 * possible object is 973 * {@link String } 974 * 975 */ 976 public String getLocker() { 977 return locker; 978 } 979 980 /** 981 * Sets the value of the locker property. 982 * 983 * @param value 984 * allowed object is 985 * {@link String } 986 * 987 */ 988 public void setLocker(String value) { 989 this.locker = value; 990 } 991 992 /** 993 * Gets the value of the maxAsyncJobs property. 994 * 995 * @return 996 * possible object is 997 * {@link BigInteger } 998 * 999 */ 1000 public BigInteger getMaxAsyncJobs() { 1001 return maxAsyncJobs; 1002 } 1003 1004 /** 1005 * Sets the value of the maxAsyncJobs property. 1006 * 1007 * @param value 1008 * allowed object is 1009 * {@link BigInteger } 1010 * 1011 */ 1012 public void setMaxAsyncJobs(BigInteger value) { 1013 this.maxAsyncJobs = value; 1014 } 1015 1016 /** 1017 * Gets the value of the maxFailoverProducersToTrack property. 1018 * 1019 * @return 1020 * possible object is 1021 * {@link BigInteger } 1022 * 1023 */ 1024 public BigInteger getMaxFailoverProducersToTrack() { 1025 return maxFailoverProducersToTrack; 1026 } 1027 1028 /** 1029 * Sets the value of the maxFailoverProducersToTrack property. 1030 * 1031 * @param value 1032 * allowed object is 1033 * {@link BigInteger } 1034 * 1035 */ 1036 public void setMaxFailoverProducersToTrack(BigInteger value) { 1037 this.maxFailoverProducersToTrack = value; 1038 } 1039 1040 /** 1041 * Gets the value of the scheduledThreadPoolExecutor property. 1042 * 1043 * @return 1044 * possible object is 1045 * {@link String } 1046 * 1047 */ 1048 public String getScheduledThreadPoolExecutor() { 1049 return scheduledThreadPoolExecutor; 1050 } 1051 1052 /** 1053 * Sets the value of the scheduledThreadPoolExecutor property. 1054 * 1055 * @param value 1056 * allowed object is 1057 * {@link String } 1058 * 1059 */ 1060 public void setScheduledThreadPoolExecutor(String value) { 1061 this.scheduledThreadPoolExecutor = value; 1062 } 1063 1064 /** 1065 * Gets the value of the transactionIdTransformer property. 1066 * 1067 * @return 1068 * possible object is 1069 * {@link String } 1070 * 1071 */ 1072 public String getTransactionIdTransformer() { 1073 return transactionIdTransformer; 1074 } 1075 1076 /** 1077 * Sets the value of the transactionIdTransformer property. 1078 * 1079 * @param value 1080 * allowed object is 1081 * {@link String } 1082 * 1083 */ 1084 public void setTransactionIdTransformer(String value) { 1085 this.transactionIdTransformer = value; 1086 } 1087 1088 /** 1089 * Gets the value of the usageManager property. 1090 * 1091 * @return 1092 * possible object is 1093 * {@link String } 1094 * 1095 */ 1096 public String getUsageManager() { 1097 return usageManager; 1098 } 1099 1100 /** 1101 * Sets the value of the usageManager property. 1102 * 1103 * @param value 1104 * allowed object is 1105 * {@link String } 1106 * 1107 */ 1108 public void setUsageManager(String value) { 1109 this.usageManager = value; 1110 } 1111 1112 /** 1113 * Gets the value of the useIndexLFRUEviction property. 1114 * 1115 * @return 1116 * possible object is 1117 * {@link Boolean } 1118 * 1119 */ 1120 public Boolean isUseIndexLFRUEviction() { 1121 return useIndexLFRUEviction; 1122 } 1123 1124 /** 1125 * Sets the value of the useIndexLFRUEviction property. 1126 * 1127 * @param value 1128 * allowed object is 1129 * {@link Boolean } 1130 * 1131 */ 1132 public void setUseIndexLFRUEviction(Boolean value) { 1133 this.useIndexLFRUEviction = value; 1134 } 1135 1136 /** 1137 * Gets the value of the useLock property. 1138 * 1139 * @return 1140 * possible object is 1141 * {@link Boolean } 1142 * 1143 */ 1144 public Boolean isUseLock() { 1145 return useLock; 1146 } 1147 1148 /** 1149 * Sets the value of the useLock property. 1150 * 1151 * @param value 1152 * allowed object is 1153 * {@link Boolean } 1154 * 1155 */ 1156 public void setUseLock(Boolean value) { 1157 this.useLock = value; 1158 } 1159 1160 /** 1161 * Gets the value of the id property. 1162 * 1163 * @return 1164 * possible object is 1165 * {@link String } 1166 * 1167 */ 1168 public String getId() { 1169 return id; 1170 } 1171 1172 /** 1173 * Sets the value of the id property. 1174 * 1175 * @param value 1176 * allowed object is 1177 * {@link String } 1178 * 1179 */ 1180 public void setId(String value) { 1181 this.id = value; 1182 } 1183 1184 /** 1185 * Gets a map that contains attributes that aren't bound to any typed property on this class. 1186 * 1187 * <p> 1188 * the map is keyed by the name of the attribute and 1189 * the value is the string value of the attribute. 1190 * 1191 * the map returned by this method is live, and you can add new attribute 1192 * by updating the map directly. Because of this design, there's no setter. 1193 * 1194 * 1195 * @return 1196 * always non-null 1197 */ 1198 public Map<QName, String> getOtherAttributes() { 1199 return otherAttributes; 1200 } 1201 1202 public String toString() { 1203 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1204 final StringBuilder buffer = new StringBuilder(); 1205 append(null, buffer, strategy); 1206 return buffer.toString(); 1207 } 1208 1209 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1210 strategy.appendStart(locator, this, buffer); 1211 appendFields(locator, buffer, strategy); 1212 strategy.appendEnd(locator, this, buffer); 1213 return buffer; 1214 } 1215 1216 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1217 { 1218 List<Object> theBrokerServiceOrLockerOrScheduledThreadPoolExecutor; 1219 theBrokerServiceOrLockerOrScheduledThreadPoolExecutor = (((this.brokerServiceOrLockerOrScheduledThreadPoolExecutor!= null)&&(!this.brokerServiceOrLockerOrScheduledThreadPoolExecutor.isEmpty()))?this.getBrokerServiceOrLockerOrScheduledThreadPoolExecutor():null); 1220 strategy.appendField(locator, this, "brokerServiceOrLockerOrScheduledThreadPoolExecutor", buffer, theBrokerServiceOrLockerOrScheduledThreadPoolExecutor); 1221 } 1222 { 1223 Boolean theArchiveCorruptedIndex; 1224 theArchiveCorruptedIndex = this.isArchiveCorruptedIndex(); 1225 strategy.appendField(locator, this, "archiveCorruptedIndex", buffer, theArchiveCorruptedIndex); 1226 } 1227 { 1228 Boolean theArchiveDataLogs; 1229 theArchiveDataLogs = this.isArchiveDataLogs(); 1230 strategy.appendField(locator, this, "archiveDataLogs", buffer, theArchiveDataLogs); 1231 } 1232 { 1233 String theBrokerName; 1234 theBrokerName = this.getBrokerName(); 1235 strategy.appendField(locator, this, "brokerName", buffer, theBrokerName); 1236 } 1237 { 1238 String theBrokerService; 1239 theBrokerService = this.getBrokerService(); 1240 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 1241 } 1242 { 1243 Boolean theCheckForCorruptJournalFiles; 1244 theCheckForCorruptJournalFiles = this.isCheckForCorruptJournalFiles(); 1245 strategy.appendField(locator, this, "checkForCorruptJournalFiles", buffer, theCheckForCorruptJournalFiles); 1246 } 1247 { 1248 Long theCheckpointInterval; 1249 theCheckpointInterval = this.getCheckpointInterval(); 1250 strategy.appendField(locator, this, "checkpointInterval", buffer, theCheckpointInterval); 1251 } 1252 { 1253 Boolean theChecksumJournalFiles; 1254 theChecksumJournalFiles = this.isChecksumJournalFiles(); 1255 strategy.appendField(locator, this, "checksumJournalFiles", buffer, theChecksumJournalFiles); 1256 } 1257 { 1258 Long theCleanupInterval; 1259 theCleanupInterval = this.getCleanupInterval(); 1260 strategy.appendField(locator, this, "cleanupInterval", buffer, theCleanupInterval); 1261 } 1262 { 1263 Boolean theConcurrentStoreAndDispatchQueues; 1264 theConcurrentStoreAndDispatchQueues = this.isConcurrentStoreAndDispatchQueues(); 1265 strategy.appendField(locator, this, "concurrentStoreAndDispatchQueues", buffer, theConcurrentStoreAndDispatchQueues); 1266 } 1267 { 1268 Boolean theConcurrentStoreAndDispatchTopics; 1269 theConcurrentStoreAndDispatchTopics = this.isConcurrentStoreAndDispatchTopics(); 1270 strategy.appendField(locator, this, "concurrentStoreAndDispatchTopics", buffer, theConcurrentStoreAndDispatchTopics); 1271 } 1272 { 1273 BigInteger theDatabaseLockedWaitDelay; 1274 theDatabaseLockedWaitDelay = this.getDatabaseLockedWaitDelay(); 1275 strategy.appendField(locator, this, "databaseLockedWaitDelay", buffer, theDatabaseLockedWaitDelay); 1276 } 1277 { 1278 String theDirectory; 1279 theDirectory = this.getDirectory(); 1280 strategy.appendField(locator, this, "directory", buffer, theDirectory); 1281 } 1282 { 1283 String theDirectoryArchive; 1284 theDirectoryArchive = this.getDirectoryArchive(); 1285 strategy.appendField(locator, this, "directoryArchive", buffer, theDirectoryArchive); 1286 } 1287 { 1288 Boolean theEnableIndexDiskSyncs; 1289 theEnableIndexDiskSyncs = this.isEnableIndexDiskSyncs(); 1290 strategy.appendField(locator, this, "enableIndexDiskSyncs", buffer, theEnableIndexDiskSyncs); 1291 } 1292 { 1293 Boolean theEnableIndexPageCaching; 1294 theEnableIndexPageCaching = this.isEnableIndexPageCaching(); 1295 strategy.appendField(locator, this, "enableIndexPageCaching", buffer, theEnableIndexPageCaching); 1296 } 1297 { 1298 Boolean theEnableIndexRecoveryFile; 1299 theEnableIndexRecoveryFile = this.isEnableIndexRecoveryFile(); 1300 strategy.appendField(locator, this, "enableIndexRecoveryFile", buffer, theEnableIndexRecoveryFile); 1301 } 1302 { 1303 Boolean theEnableIndexWriteAsync; 1304 theEnableIndexWriteAsync = this.isEnableIndexWriteAsync(); 1305 strategy.appendField(locator, this, "enableIndexWriteAsync", buffer, theEnableIndexWriteAsync); 1306 } 1307 { 1308 Boolean theEnableJournalDiskSyncs; 1309 theEnableJournalDiskSyncs = this.isEnableJournalDiskSyncs(); 1310 strategy.appendField(locator, this, "enableJournalDiskSyncs", buffer, theEnableJournalDiskSyncs); 1311 } 1312 { 1313 BigInteger theFailoverProducersAuditDepth; 1314 theFailoverProducersAuditDepth = this.getFailoverProducersAuditDepth(); 1315 strategy.appendField(locator, this, "failoverProducersAuditDepth", buffer, theFailoverProducersAuditDepth); 1316 } 1317 { 1318 Boolean theForceRecoverIndex; 1319 theForceRecoverIndex = this.isForceRecoverIndex(); 1320 strategy.appendField(locator, this, "forceRecoverIndex", buffer, theForceRecoverIndex); 1321 } 1322 { 1323 Boolean theIgnoreMissingJournalfiles; 1324 theIgnoreMissingJournalfiles = this.isIgnoreMissingJournalfiles(); 1325 strategy.appendField(locator, this, "ignoreMissingJournalfiles", buffer, theIgnoreMissingJournalfiles); 1326 } 1327 { 1328 String theIndexCacheSize; 1329 theIndexCacheSize = this.getIndexCacheSize(); 1330 strategy.appendField(locator, this, "indexCacheSize", buffer, theIndexCacheSize); 1331 } 1332 { 1333 String theIndexDirectory; 1334 theIndexDirectory = this.getIndexDirectory(); 1335 strategy.appendField(locator, this, "indexDirectory", buffer, theIndexDirectory); 1336 } 1337 { 1338 Float theIndexLFUEvictionFactor; 1339 theIndexLFUEvictionFactor = this.getIndexLFUEvictionFactor(); 1340 strategy.appendField(locator, this, "indexLFUEvictionFactor", buffer, theIndexLFUEvictionFactor); 1341 } 1342 { 1343 String theIndexWriteBatchSize; 1344 theIndexWriteBatchSize = this.getIndexWriteBatchSize(); 1345 strategy.appendField(locator, this, "indexWriteBatchSize", buffer, theIndexWriteBatchSize); 1346 } 1347 { 1348 String theJournalMaxFileLength; 1349 theJournalMaxFileLength = this.getJournalMaxFileLength(); 1350 strategy.appendField(locator, this, "journalMaxFileLength", buffer, theJournalMaxFileLength); 1351 } 1352 { 1353 String theJournalMaxWriteBatchSize; 1354 theJournalMaxWriteBatchSize = this.getJournalMaxWriteBatchSize(); 1355 strategy.appendField(locator, this, "journalMaxWriteBatchSize", buffer, theJournalMaxWriteBatchSize); 1356 } 1357 { 1358 Long theLockKeepAlivePeriod; 1359 theLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1360 strategy.appendField(locator, this, "lockKeepAlivePeriod", buffer, theLockKeepAlivePeriod); 1361 } 1362 { 1363 String theLocker; 1364 theLocker = this.getLocker(); 1365 strategy.appendField(locator, this, "locker", buffer, theLocker); 1366 } 1367 { 1368 BigInteger theMaxAsyncJobs; 1369 theMaxAsyncJobs = this.getMaxAsyncJobs(); 1370 strategy.appendField(locator, this, "maxAsyncJobs", buffer, theMaxAsyncJobs); 1371 } 1372 { 1373 BigInteger theMaxFailoverProducersToTrack; 1374 theMaxFailoverProducersToTrack = this.getMaxFailoverProducersToTrack(); 1375 strategy.appendField(locator, this, "maxFailoverProducersToTrack", buffer, theMaxFailoverProducersToTrack); 1376 } 1377 { 1378 String theScheduledThreadPoolExecutor; 1379 theScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1380 strategy.appendField(locator, this, "scheduledThreadPoolExecutor", buffer, theScheduledThreadPoolExecutor); 1381 } 1382 { 1383 String theTransactionIdTransformer; 1384 theTransactionIdTransformer = this.getTransactionIdTransformer(); 1385 strategy.appendField(locator, this, "transactionIdTransformer", buffer, theTransactionIdTransformer); 1386 } 1387 { 1388 String theUsageManager; 1389 theUsageManager = this.getUsageManager(); 1390 strategy.appendField(locator, this, "usageManager", buffer, theUsageManager); 1391 } 1392 { 1393 Boolean theUseIndexLFRUEviction; 1394 theUseIndexLFRUEviction = this.isUseIndexLFRUEviction(); 1395 strategy.appendField(locator, this, "useIndexLFRUEviction", buffer, theUseIndexLFRUEviction); 1396 } 1397 { 1398 Boolean theUseLock; 1399 theUseLock = this.isUseLock(); 1400 strategy.appendField(locator, this, "useLock", buffer, theUseLock); 1401 } 1402 { 1403 String theId; 1404 theId = this.getId(); 1405 strategy.appendField(locator, this, "id", buffer, theId); 1406 } 1407 return buffer; 1408 } 1409 1410 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1411 int currentHashCode = 1; 1412 { 1413 List<Object> theBrokerServiceOrLockerOrScheduledThreadPoolExecutor; 1414 theBrokerServiceOrLockerOrScheduledThreadPoolExecutor = (((this.brokerServiceOrLockerOrScheduledThreadPoolExecutor!= null)&&(!this.brokerServiceOrLockerOrScheduledThreadPoolExecutor.isEmpty()))?this.getBrokerServiceOrLockerOrScheduledThreadPoolExecutor():null); 1415 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerServiceOrLockerOrScheduledThreadPoolExecutor", theBrokerServiceOrLockerOrScheduledThreadPoolExecutor), currentHashCode, theBrokerServiceOrLockerOrScheduledThreadPoolExecutor); 1416 } 1417 { 1418 Boolean theArchiveCorruptedIndex; 1419 theArchiveCorruptedIndex = this.isArchiveCorruptedIndex(); 1420 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "archiveCorruptedIndex", theArchiveCorruptedIndex), currentHashCode, theArchiveCorruptedIndex); 1421 } 1422 { 1423 Boolean theArchiveDataLogs; 1424 theArchiveDataLogs = this.isArchiveDataLogs(); 1425 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "archiveDataLogs", theArchiveDataLogs), currentHashCode, theArchiveDataLogs); 1426 } 1427 { 1428 String theBrokerName; 1429 theBrokerName = this.getBrokerName(); 1430 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerName", theBrokerName), currentHashCode, theBrokerName); 1431 } 1432 { 1433 String theBrokerService; 1434 theBrokerService = this.getBrokerService(); 1435 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 1436 } 1437 { 1438 Boolean theCheckForCorruptJournalFiles; 1439 theCheckForCorruptJournalFiles = this.isCheckForCorruptJournalFiles(); 1440 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "checkForCorruptJournalFiles", theCheckForCorruptJournalFiles), currentHashCode, theCheckForCorruptJournalFiles); 1441 } 1442 { 1443 Long theCheckpointInterval; 1444 theCheckpointInterval = this.getCheckpointInterval(); 1445 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "checkpointInterval", theCheckpointInterval), currentHashCode, theCheckpointInterval); 1446 } 1447 { 1448 Boolean theChecksumJournalFiles; 1449 theChecksumJournalFiles = this.isChecksumJournalFiles(); 1450 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "checksumJournalFiles", theChecksumJournalFiles), currentHashCode, theChecksumJournalFiles); 1451 } 1452 { 1453 Long theCleanupInterval; 1454 theCleanupInterval = this.getCleanupInterval(); 1455 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "cleanupInterval", theCleanupInterval), currentHashCode, theCleanupInterval); 1456 } 1457 { 1458 Boolean theConcurrentStoreAndDispatchQueues; 1459 theConcurrentStoreAndDispatchQueues = this.isConcurrentStoreAndDispatchQueues(); 1460 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "concurrentStoreAndDispatchQueues", theConcurrentStoreAndDispatchQueues), currentHashCode, theConcurrentStoreAndDispatchQueues); 1461 } 1462 { 1463 Boolean theConcurrentStoreAndDispatchTopics; 1464 theConcurrentStoreAndDispatchTopics = this.isConcurrentStoreAndDispatchTopics(); 1465 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "concurrentStoreAndDispatchTopics", theConcurrentStoreAndDispatchTopics), currentHashCode, theConcurrentStoreAndDispatchTopics); 1466 } 1467 { 1468 BigInteger theDatabaseLockedWaitDelay; 1469 theDatabaseLockedWaitDelay = this.getDatabaseLockedWaitDelay(); 1470 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "databaseLockedWaitDelay", theDatabaseLockedWaitDelay), currentHashCode, theDatabaseLockedWaitDelay); 1471 } 1472 { 1473 String theDirectory; 1474 theDirectory = this.getDirectory(); 1475 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "directory", theDirectory), currentHashCode, theDirectory); 1476 } 1477 { 1478 String theDirectoryArchive; 1479 theDirectoryArchive = this.getDirectoryArchive(); 1480 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "directoryArchive", theDirectoryArchive), currentHashCode, theDirectoryArchive); 1481 } 1482 { 1483 Boolean theEnableIndexDiskSyncs; 1484 theEnableIndexDiskSyncs = this.isEnableIndexDiskSyncs(); 1485 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableIndexDiskSyncs", theEnableIndexDiskSyncs), currentHashCode, theEnableIndexDiskSyncs); 1486 } 1487 { 1488 Boolean theEnableIndexPageCaching; 1489 theEnableIndexPageCaching = this.isEnableIndexPageCaching(); 1490 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableIndexPageCaching", theEnableIndexPageCaching), currentHashCode, theEnableIndexPageCaching); 1491 } 1492 { 1493 Boolean theEnableIndexRecoveryFile; 1494 theEnableIndexRecoveryFile = this.isEnableIndexRecoveryFile(); 1495 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableIndexRecoveryFile", theEnableIndexRecoveryFile), currentHashCode, theEnableIndexRecoveryFile); 1496 } 1497 { 1498 Boolean theEnableIndexWriteAsync; 1499 theEnableIndexWriteAsync = this.isEnableIndexWriteAsync(); 1500 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableIndexWriteAsync", theEnableIndexWriteAsync), currentHashCode, theEnableIndexWriteAsync); 1501 } 1502 { 1503 Boolean theEnableJournalDiskSyncs; 1504 theEnableJournalDiskSyncs = this.isEnableJournalDiskSyncs(); 1505 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableJournalDiskSyncs", theEnableJournalDiskSyncs), currentHashCode, theEnableJournalDiskSyncs); 1506 } 1507 { 1508 BigInteger theFailoverProducersAuditDepth; 1509 theFailoverProducersAuditDepth = this.getFailoverProducersAuditDepth(); 1510 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "failoverProducersAuditDepth", theFailoverProducersAuditDepth), currentHashCode, theFailoverProducersAuditDepth); 1511 } 1512 { 1513 Boolean theForceRecoverIndex; 1514 theForceRecoverIndex = this.isForceRecoverIndex(); 1515 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "forceRecoverIndex", theForceRecoverIndex), currentHashCode, theForceRecoverIndex); 1516 } 1517 { 1518 Boolean theIgnoreMissingJournalfiles; 1519 theIgnoreMissingJournalfiles = this.isIgnoreMissingJournalfiles(); 1520 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "ignoreMissingJournalfiles", theIgnoreMissingJournalfiles), currentHashCode, theIgnoreMissingJournalfiles); 1521 } 1522 { 1523 String theIndexCacheSize; 1524 theIndexCacheSize = this.getIndexCacheSize(); 1525 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "indexCacheSize", theIndexCacheSize), currentHashCode, theIndexCacheSize); 1526 } 1527 { 1528 String theIndexDirectory; 1529 theIndexDirectory = this.getIndexDirectory(); 1530 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "indexDirectory", theIndexDirectory), currentHashCode, theIndexDirectory); 1531 } 1532 { 1533 Float theIndexLFUEvictionFactor; 1534 theIndexLFUEvictionFactor = this.getIndexLFUEvictionFactor(); 1535 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "indexLFUEvictionFactor", theIndexLFUEvictionFactor), currentHashCode, theIndexLFUEvictionFactor); 1536 } 1537 { 1538 String theIndexWriteBatchSize; 1539 theIndexWriteBatchSize = this.getIndexWriteBatchSize(); 1540 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "indexWriteBatchSize", theIndexWriteBatchSize), currentHashCode, theIndexWriteBatchSize); 1541 } 1542 { 1543 String theJournalMaxFileLength; 1544 theJournalMaxFileLength = this.getJournalMaxFileLength(); 1545 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "journalMaxFileLength", theJournalMaxFileLength), currentHashCode, theJournalMaxFileLength); 1546 } 1547 { 1548 String theJournalMaxWriteBatchSize; 1549 theJournalMaxWriteBatchSize = this.getJournalMaxWriteBatchSize(); 1550 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "journalMaxWriteBatchSize", theJournalMaxWriteBatchSize), currentHashCode, theJournalMaxWriteBatchSize); 1551 } 1552 { 1553 Long theLockKeepAlivePeriod; 1554 theLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1555 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "lockKeepAlivePeriod", theLockKeepAlivePeriod), currentHashCode, theLockKeepAlivePeriod); 1556 } 1557 { 1558 String theLocker; 1559 theLocker = this.getLocker(); 1560 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "locker", theLocker), currentHashCode, theLocker); 1561 } 1562 { 1563 BigInteger theMaxAsyncJobs; 1564 theMaxAsyncJobs = this.getMaxAsyncJobs(); 1565 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxAsyncJobs", theMaxAsyncJobs), currentHashCode, theMaxAsyncJobs); 1566 } 1567 { 1568 BigInteger theMaxFailoverProducersToTrack; 1569 theMaxFailoverProducersToTrack = this.getMaxFailoverProducersToTrack(); 1570 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxFailoverProducersToTrack", theMaxFailoverProducersToTrack), currentHashCode, theMaxFailoverProducersToTrack); 1571 } 1572 { 1573 String theScheduledThreadPoolExecutor; 1574 theScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1575 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "scheduledThreadPoolExecutor", theScheduledThreadPoolExecutor), currentHashCode, theScheduledThreadPoolExecutor); 1576 } 1577 { 1578 String theTransactionIdTransformer; 1579 theTransactionIdTransformer = this.getTransactionIdTransformer(); 1580 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactionIdTransformer", theTransactionIdTransformer), currentHashCode, theTransactionIdTransformer); 1581 } 1582 { 1583 String theUsageManager; 1584 theUsageManager = this.getUsageManager(); 1585 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "usageManager", theUsageManager), currentHashCode, theUsageManager); 1586 } 1587 { 1588 Boolean theUseIndexLFRUEviction; 1589 theUseIndexLFRUEviction = this.isUseIndexLFRUEviction(); 1590 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useIndexLFRUEviction", theUseIndexLFRUEviction), currentHashCode, theUseIndexLFRUEviction); 1591 } 1592 { 1593 Boolean theUseLock; 1594 theUseLock = this.isUseLock(); 1595 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useLock", theUseLock), currentHashCode, theUseLock); 1596 } 1597 { 1598 String theId; 1599 theId = this.getId(); 1600 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 1601 } 1602 return currentHashCode; 1603 } 1604 1605 public int hashCode() { 1606 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1607 return this.hashCode(null, strategy); 1608 } 1609 1610 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1611 if (!(object instanceof DtoKahaDB)) { 1612 return false; 1613 } 1614 if (this == object) { 1615 return true; 1616 } 1617 final DtoKahaDB that = ((DtoKahaDB) object); 1618 { 1619 List<Object> lhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor; 1620 lhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor = (((this.brokerServiceOrLockerOrScheduledThreadPoolExecutor!= null)&&(!this.brokerServiceOrLockerOrScheduledThreadPoolExecutor.isEmpty()))?this.getBrokerServiceOrLockerOrScheduledThreadPoolExecutor():null); 1621 List<Object> rhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor; 1622 rhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor = (((that.brokerServiceOrLockerOrScheduledThreadPoolExecutor!= null)&&(!that.brokerServiceOrLockerOrScheduledThreadPoolExecutor.isEmpty()))?that.getBrokerServiceOrLockerOrScheduledThreadPoolExecutor():null); 1623 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerServiceOrLockerOrScheduledThreadPoolExecutor", lhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor), LocatorUtils.property(thatLocator, "brokerServiceOrLockerOrScheduledThreadPoolExecutor", rhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor), lhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor, rhsBrokerServiceOrLockerOrScheduledThreadPoolExecutor)) { 1624 return false; 1625 } 1626 } 1627 { 1628 Boolean lhsArchiveCorruptedIndex; 1629 lhsArchiveCorruptedIndex = this.isArchiveCorruptedIndex(); 1630 Boolean rhsArchiveCorruptedIndex; 1631 rhsArchiveCorruptedIndex = that.isArchiveCorruptedIndex(); 1632 if (!strategy.equals(LocatorUtils.property(thisLocator, "archiveCorruptedIndex", lhsArchiveCorruptedIndex), LocatorUtils.property(thatLocator, "archiveCorruptedIndex", rhsArchiveCorruptedIndex), lhsArchiveCorruptedIndex, rhsArchiveCorruptedIndex)) { 1633 return false; 1634 } 1635 } 1636 { 1637 Boolean lhsArchiveDataLogs; 1638 lhsArchiveDataLogs = this.isArchiveDataLogs(); 1639 Boolean rhsArchiveDataLogs; 1640 rhsArchiveDataLogs = that.isArchiveDataLogs(); 1641 if (!strategy.equals(LocatorUtils.property(thisLocator, "archiveDataLogs", lhsArchiveDataLogs), LocatorUtils.property(thatLocator, "archiveDataLogs", rhsArchiveDataLogs), lhsArchiveDataLogs, rhsArchiveDataLogs)) { 1642 return false; 1643 } 1644 } 1645 { 1646 String lhsBrokerName; 1647 lhsBrokerName = this.getBrokerName(); 1648 String rhsBrokerName; 1649 rhsBrokerName = that.getBrokerName(); 1650 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerName", lhsBrokerName), LocatorUtils.property(thatLocator, "brokerName", rhsBrokerName), lhsBrokerName, rhsBrokerName)) { 1651 return false; 1652 } 1653 } 1654 { 1655 String lhsBrokerService; 1656 lhsBrokerService = this.getBrokerService(); 1657 String rhsBrokerService; 1658 rhsBrokerService = that.getBrokerService(); 1659 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 1660 return false; 1661 } 1662 } 1663 { 1664 Boolean lhsCheckForCorruptJournalFiles; 1665 lhsCheckForCorruptJournalFiles = this.isCheckForCorruptJournalFiles(); 1666 Boolean rhsCheckForCorruptJournalFiles; 1667 rhsCheckForCorruptJournalFiles = that.isCheckForCorruptJournalFiles(); 1668 if (!strategy.equals(LocatorUtils.property(thisLocator, "checkForCorruptJournalFiles", lhsCheckForCorruptJournalFiles), LocatorUtils.property(thatLocator, "checkForCorruptJournalFiles", rhsCheckForCorruptJournalFiles), lhsCheckForCorruptJournalFiles, rhsCheckForCorruptJournalFiles)) { 1669 return false; 1670 } 1671 } 1672 { 1673 Long lhsCheckpointInterval; 1674 lhsCheckpointInterval = this.getCheckpointInterval(); 1675 Long rhsCheckpointInterval; 1676 rhsCheckpointInterval = that.getCheckpointInterval(); 1677 if (!strategy.equals(LocatorUtils.property(thisLocator, "checkpointInterval", lhsCheckpointInterval), LocatorUtils.property(thatLocator, "checkpointInterval", rhsCheckpointInterval), lhsCheckpointInterval, rhsCheckpointInterval)) { 1678 return false; 1679 } 1680 } 1681 { 1682 Boolean lhsChecksumJournalFiles; 1683 lhsChecksumJournalFiles = this.isChecksumJournalFiles(); 1684 Boolean rhsChecksumJournalFiles; 1685 rhsChecksumJournalFiles = that.isChecksumJournalFiles(); 1686 if (!strategy.equals(LocatorUtils.property(thisLocator, "checksumJournalFiles", lhsChecksumJournalFiles), LocatorUtils.property(thatLocator, "checksumJournalFiles", rhsChecksumJournalFiles), lhsChecksumJournalFiles, rhsChecksumJournalFiles)) { 1687 return false; 1688 } 1689 } 1690 { 1691 Long lhsCleanupInterval; 1692 lhsCleanupInterval = this.getCleanupInterval(); 1693 Long rhsCleanupInterval; 1694 rhsCleanupInterval = that.getCleanupInterval(); 1695 if (!strategy.equals(LocatorUtils.property(thisLocator, "cleanupInterval", lhsCleanupInterval), LocatorUtils.property(thatLocator, "cleanupInterval", rhsCleanupInterval), lhsCleanupInterval, rhsCleanupInterval)) { 1696 return false; 1697 } 1698 } 1699 { 1700 Boolean lhsConcurrentStoreAndDispatchQueues; 1701 lhsConcurrentStoreAndDispatchQueues = this.isConcurrentStoreAndDispatchQueues(); 1702 Boolean rhsConcurrentStoreAndDispatchQueues; 1703 rhsConcurrentStoreAndDispatchQueues = that.isConcurrentStoreAndDispatchQueues(); 1704 if (!strategy.equals(LocatorUtils.property(thisLocator, "concurrentStoreAndDispatchQueues", lhsConcurrentStoreAndDispatchQueues), LocatorUtils.property(thatLocator, "concurrentStoreAndDispatchQueues", rhsConcurrentStoreAndDispatchQueues), lhsConcurrentStoreAndDispatchQueues, rhsConcurrentStoreAndDispatchQueues)) { 1705 return false; 1706 } 1707 } 1708 { 1709 Boolean lhsConcurrentStoreAndDispatchTopics; 1710 lhsConcurrentStoreAndDispatchTopics = this.isConcurrentStoreAndDispatchTopics(); 1711 Boolean rhsConcurrentStoreAndDispatchTopics; 1712 rhsConcurrentStoreAndDispatchTopics = that.isConcurrentStoreAndDispatchTopics(); 1713 if (!strategy.equals(LocatorUtils.property(thisLocator, "concurrentStoreAndDispatchTopics", lhsConcurrentStoreAndDispatchTopics), LocatorUtils.property(thatLocator, "concurrentStoreAndDispatchTopics", rhsConcurrentStoreAndDispatchTopics), lhsConcurrentStoreAndDispatchTopics, rhsConcurrentStoreAndDispatchTopics)) { 1714 return false; 1715 } 1716 } 1717 { 1718 BigInteger lhsDatabaseLockedWaitDelay; 1719 lhsDatabaseLockedWaitDelay = this.getDatabaseLockedWaitDelay(); 1720 BigInteger rhsDatabaseLockedWaitDelay; 1721 rhsDatabaseLockedWaitDelay = that.getDatabaseLockedWaitDelay(); 1722 if (!strategy.equals(LocatorUtils.property(thisLocator, "databaseLockedWaitDelay", lhsDatabaseLockedWaitDelay), LocatorUtils.property(thatLocator, "databaseLockedWaitDelay", rhsDatabaseLockedWaitDelay), lhsDatabaseLockedWaitDelay, rhsDatabaseLockedWaitDelay)) { 1723 return false; 1724 } 1725 } 1726 { 1727 String lhsDirectory; 1728 lhsDirectory = this.getDirectory(); 1729 String rhsDirectory; 1730 rhsDirectory = that.getDirectory(); 1731 if (!strategy.equals(LocatorUtils.property(thisLocator, "directory", lhsDirectory), LocatorUtils.property(thatLocator, "directory", rhsDirectory), lhsDirectory, rhsDirectory)) { 1732 return false; 1733 } 1734 } 1735 { 1736 String lhsDirectoryArchive; 1737 lhsDirectoryArchive = this.getDirectoryArchive(); 1738 String rhsDirectoryArchive; 1739 rhsDirectoryArchive = that.getDirectoryArchive(); 1740 if (!strategy.equals(LocatorUtils.property(thisLocator, "directoryArchive", lhsDirectoryArchive), LocatorUtils.property(thatLocator, "directoryArchive", rhsDirectoryArchive), lhsDirectoryArchive, rhsDirectoryArchive)) { 1741 return false; 1742 } 1743 } 1744 { 1745 Boolean lhsEnableIndexDiskSyncs; 1746 lhsEnableIndexDiskSyncs = this.isEnableIndexDiskSyncs(); 1747 Boolean rhsEnableIndexDiskSyncs; 1748 rhsEnableIndexDiskSyncs = that.isEnableIndexDiskSyncs(); 1749 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableIndexDiskSyncs", lhsEnableIndexDiskSyncs), LocatorUtils.property(thatLocator, "enableIndexDiskSyncs", rhsEnableIndexDiskSyncs), lhsEnableIndexDiskSyncs, rhsEnableIndexDiskSyncs)) { 1750 return false; 1751 } 1752 } 1753 { 1754 Boolean lhsEnableIndexPageCaching; 1755 lhsEnableIndexPageCaching = this.isEnableIndexPageCaching(); 1756 Boolean rhsEnableIndexPageCaching; 1757 rhsEnableIndexPageCaching = that.isEnableIndexPageCaching(); 1758 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableIndexPageCaching", lhsEnableIndexPageCaching), LocatorUtils.property(thatLocator, "enableIndexPageCaching", rhsEnableIndexPageCaching), lhsEnableIndexPageCaching, rhsEnableIndexPageCaching)) { 1759 return false; 1760 } 1761 } 1762 { 1763 Boolean lhsEnableIndexRecoveryFile; 1764 lhsEnableIndexRecoveryFile = this.isEnableIndexRecoveryFile(); 1765 Boolean rhsEnableIndexRecoveryFile; 1766 rhsEnableIndexRecoveryFile = that.isEnableIndexRecoveryFile(); 1767 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableIndexRecoveryFile", lhsEnableIndexRecoveryFile), LocatorUtils.property(thatLocator, "enableIndexRecoveryFile", rhsEnableIndexRecoveryFile), lhsEnableIndexRecoveryFile, rhsEnableIndexRecoveryFile)) { 1768 return false; 1769 } 1770 } 1771 { 1772 Boolean lhsEnableIndexWriteAsync; 1773 lhsEnableIndexWriteAsync = this.isEnableIndexWriteAsync(); 1774 Boolean rhsEnableIndexWriteAsync; 1775 rhsEnableIndexWriteAsync = that.isEnableIndexWriteAsync(); 1776 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableIndexWriteAsync", lhsEnableIndexWriteAsync), LocatorUtils.property(thatLocator, "enableIndexWriteAsync", rhsEnableIndexWriteAsync), lhsEnableIndexWriteAsync, rhsEnableIndexWriteAsync)) { 1777 return false; 1778 } 1779 } 1780 { 1781 Boolean lhsEnableJournalDiskSyncs; 1782 lhsEnableJournalDiskSyncs = this.isEnableJournalDiskSyncs(); 1783 Boolean rhsEnableJournalDiskSyncs; 1784 rhsEnableJournalDiskSyncs = that.isEnableJournalDiskSyncs(); 1785 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableJournalDiskSyncs", lhsEnableJournalDiskSyncs), LocatorUtils.property(thatLocator, "enableJournalDiskSyncs", rhsEnableJournalDiskSyncs), lhsEnableJournalDiskSyncs, rhsEnableJournalDiskSyncs)) { 1786 return false; 1787 } 1788 } 1789 { 1790 BigInteger lhsFailoverProducersAuditDepth; 1791 lhsFailoverProducersAuditDepth = this.getFailoverProducersAuditDepth(); 1792 BigInteger rhsFailoverProducersAuditDepth; 1793 rhsFailoverProducersAuditDepth = that.getFailoverProducersAuditDepth(); 1794 if (!strategy.equals(LocatorUtils.property(thisLocator, "failoverProducersAuditDepth", lhsFailoverProducersAuditDepth), LocatorUtils.property(thatLocator, "failoverProducersAuditDepth", rhsFailoverProducersAuditDepth), lhsFailoverProducersAuditDepth, rhsFailoverProducersAuditDepth)) { 1795 return false; 1796 } 1797 } 1798 { 1799 Boolean lhsForceRecoverIndex; 1800 lhsForceRecoverIndex = this.isForceRecoverIndex(); 1801 Boolean rhsForceRecoverIndex; 1802 rhsForceRecoverIndex = that.isForceRecoverIndex(); 1803 if (!strategy.equals(LocatorUtils.property(thisLocator, "forceRecoverIndex", lhsForceRecoverIndex), LocatorUtils.property(thatLocator, "forceRecoverIndex", rhsForceRecoverIndex), lhsForceRecoverIndex, rhsForceRecoverIndex)) { 1804 return false; 1805 } 1806 } 1807 { 1808 Boolean lhsIgnoreMissingJournalfiles; 1809 lhsIgnoreMissingJournalfiles = this.isIgnoreMissingJournalfiles(); 1810 Boolean rhsIgnoreMissingJournalfiles; 1811 rhsIgnoreMissingJournalfiles = that.isIgnoreMissingJournalfiles(); 1812 if (!strategy.equals(LocatorUtils.property(thisLocator, "ignoreMissingJournalfiles", lhsIgnoreMissingJournalfiles), LocatorUtils.property(thatLocator, "ignoreMissingJournalfiles", rhsIgnoreMissingJournalfiles), lhsIgnoreMissingJournalfiles, rhsIgnoreMissingJournalfiles)) { 1813 return false; 1814 } 1815 } 1816 { 1817 String lhsIndexCacheSize; 1818 lhsIndexCacheSize = this.getIndexCacheSize(); 1819 String rhsIndexCacheSize; 1820 rhsIndexCacheSize = that.getIndexCacheSize(); 1821 if (!strategy.equals(LocatorUtils.property(thisLocator, "indexCacheSize", lhsIndexCacheSize), LocatorUtils.property(thatLocator, "indexCacheSize", rhsIndexCacheSize), lhsIndexCacheSize, rhsIndexCacheSize)) { 1822 return false; 1823 } 1824 } 1825 { 1826 String lhsIndexDirectory; 1827 lhsIndexDirectory = this.getIndexDirectory(); 1828 String rhsIndexDirectory; 1829 rhsIndexDirectory = that.getIndexDirectory(); 1830 if (!strategy.equals(LocatorUtils.property(thisLocator, "indexDirectory", lhsIndexDirectory), LocatorUtils.property(thatLocator, "indexDirectory", rhsIndexDirectory), lhsIndexDirectory, rhsIndexDirectory)) { 1831 return false; 1832 } 1833 } 1834 { 1835 Float lhsIndexLFUEvictionFactor; 1836 lhsIndexLFUEvictionFactor = this.getIndexLFUEvictionFactor(); 1837 Float rhsIndexLFUEvictionFactor; 1838 rhsIndexLFUEvictionFactor = that.getIndexLFUEvictionFactor(); 1839 if (!strategy.equals(LocatorUtils.property(thisLocator, "indexLFUEvictionFactor", lhsIndexLFUEvictionFactor), LocatorUtils.property(thatLocator, "indexLFUEvictionFactor", rhsIndexLFUEvictionFactor), lhsIndexLFUEvictionFactor, rhsIndexLFUEvictionFactor)) { 1840 return false; 1841 } 1842 } 1843 { 1844 String lhsIndexWriteBatchSize; 1845 lhsIndexWriteBatchSize = this.getIndexWriteBatchSize(); 1846 String rhsIndexWriteBatchSize; 1847 rhsIndexWriteBatchSize = that.getIndexWriteBatchSize(); 1848 if (!strategy.equals(LocatorUtils.property(thisLocator, "indexWriteBatchSize", lhsIndexWriteBatchSize), LocatorUtils.property(thatLocator, "indexWriteBatchSize", rhsIndexWriteBatchSize), lhsIndexWriteBatchSize, rhsIndexWriteBatchSize)) { 1849 return false; 1850 } 1851 } 1852 { 1853 String lhsJournalMaxFileLength; 1854 lhsJournalMaxFileLength = this.getJournalMaxFileLength(); 1855 String rhsJournalMaxFileLength; 1856 rhsJournalMaxFileLength = that.getJournalMaxFileLength(); 1857 if (!strategy.equals(LocatorUtils.property(thisLocator, "journalMaxFileLength", lhsJournalMaxFileLength), LocatorUtils.property(thatLocator, "journalMaxFileLength", rhsJournalMaxFileLength), lhsJournalMaxFileLength, rhsJournalMaxFileLength)) { 1858 return false; 1859 } 1860 } 1861 { 1862 String lhsJournalMaxWriteBatchSize; 1863 lhsJournalMaxWriteBatchSize = this.getJournalMaxWriteBatchSize(); 1864 String rhsJournalMaxWriteBatchSize; 1865 rhsJournalMaxWriteBatchSize = that.getJournalMaxWriteBatchSize(); 1866 if (!strategy.equals(LocatorUtils.property(thisLocator, "journalMaxWriteBatchSize", lhsJournalMaxWriteBatchSize), LocatorUtils.property(thatLocator, "journalMaxWriteBatchSize", rhsJournalMaxWriteBatchSize), lhsJournalMaxWriteBatchSize, rhsJournalMaxWriteBatchSize)) { 1867 return false; 1868 } 1869 } 1870 { 1871 Long lhsLockKeepAlivePeriod; 1872 lhsLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1873 Long rhsLockKeepAlivePeriod; 1874 rhsLockKeepAlivePeriod = that.getLockKeepAlivePeriod(); 1875 if (!strategy.equals(LocatorUtils.property(thisLocator, "lockKeepAlivePeriod", lhsLockKeepAlivePeriod), LocatorUtils.property(thatLocator, "lockKeepAlivePeriod", rhsLockKeepAlivePeriod), lhsLockKeepAlivePeriod, rhsLockKeepAlivePeriod)) { 1876 return false; 1877 } 1878 } 1879 { 1880 String lhsLocker; 1881 lhsLocker = this.getLocker(); 1882 String rhsLocker; 1883 rhsLocker = that.getLocker(); 1884 if (!strategy.equals(LocatorUtils.property(thisLocator, "locker", lhsLocker), LocatorUtils.property(thatLocator, "locker", rhsLocker), lhsLocker, rhsLocker)) { 1885 return false; 1886 } 1887 } 1888 { 1889 BigInteger lhsMaxAsyncJobs; 1890 lhsMaxAsyncJobs = this.getMaxAsyncJobs(); 1891 BigInteger rhsMaxAsyncJobs; 1892 rhsMaxAsyncJobs = that.getMaxAsyncJobs(); 1893 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxAsyncJobs", lhsMaxAsyncJobs), LocatorUtils.property(thatLocator, "maxAsyncJobs", rhsMaxAsyncJobs), lhsMaxAsyncJobs, rhsMaxAsyncJobs)) { 1894 return false; 1895 } 1896 } 1897 { 1898 BigInteger lhsMaxFailoverProducersToTrack; 1899 lhsMaxFailoverProducersToTrack = this.getMaxFailoverProducersToTrack(); 1900 BigInteger rhsMaxFailoverProducersToTrack; 1901 rhsMaxFailoverProducersToTrack = that.getMaxFailoverProducersToTrack(); 1902 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxFailoverProducersToTrack", lhsMaxFailoverProducersToTrack), LocatorUtils.property(thatLocator, "maxFailoverProducersToTrack", rhsMaxFailoverProducersToTrack), lhsMaxFailoverProducersToTrack, rhsMaxFailoverProducersToTrack)) { 1903 return false; 1904 } 1905 } 1906 { 1907 String lhsScheduledThreadPoolExecutor; 1908 lhsScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1909 String rhsScheduledThreadPoolExecutor; 1910 rhsScheduledThreadPoolExecutor = that.getScheduledThreadPoolExecutor(); 1911 if (!strategy.equals(LocatorUtils.property(thisLocator, "scheduledThreadPoolExecutor", lhsScheduledThreadPoolExecutor), LocatorUtils.property(thatLocator, "scheduledThreadPoolExecutor", rhsScheduledThreadPoolExecutor), lhsScheduledThreadPoolExecutor, rhsScheduledThreadPoolExecutor)) { 1912 return false; 1913 } 1914 } 1915 { 1916 String lhsTransactionIdTransformer; 1917 lhsTransactionIdTransformer = this.getTransactionIdTransformer(); 1918 String rhsTransactionIdTransformer; 1919 rhsTransactionIdTransformer = that.getTransactionIdTransformer(); 1920 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactionIdTransformer", lhsTransactionIdTransformer), LocatorUtils.property(thatLocator, "transactionIdTransformer", rhsTransactionIdTransformer), lhsTransactionIdTransformer, rhsTransactionIdTransformer)) { 1921 return false; 1922 } 1923 } 1924 { 1925 String lhsUsageManager; 1926 lhsUsageManager = this.getUsageManager(); 1927 String rhsUsageManager; 1928 rhsUsageManager = that.getUsageManager(); 1929 if (!strategy.equals(LocatorUtils.property(thisLocator, "usageManager", lhsUsageManager), LocatorUtils.property(thatLocator, "usageManager", rhsUsageManager), lhsUsageManager, rhsUsageManager)) { 1930 return false; 1931 } 1932 } 1933 { 1934 Boolean lhsUseIndexLFRUEviction; 1935 lhsUseIndexLFRUEviction = this.isUseIndexLFRUEviction(); 1936 Boolean rhsUseIndexLFRUEviction; 1937 rhsUseIndexLFRUEviction = that.isUseIndexLFRUEviction(); 1938 if (!strategy.equals(LocatorUtils.property(thisLocator, "useIndexLFRUEviction", lhsUseIndexLFRUEviction), LocatorUtils.property(thatLocator, "useIndexLFRUEviction", rhsUseIndexLFRUEviction), lhsUseIndexLFRUEviction, rhsUseIndexLFRUEviction)) { 1939 return false; 1940 } 1941 } 1942 { 1943 Boolean lhsUseLock; 1944 lhsUseLock = this.isUseLock(); 1945 Boolean rhsUseLock; 1946 rhsUseLock = that.isUseLock(); 1947 if (!strategy.equals(LocatorUtils.property(thisLocator, "useLock", lhsUseLock), LocatorUtils.property(thatLocator, "useLock", rhsUseLock), lhsUseLock, rhsUseLock)) { 1948 return false; 1949 } 1950 } 1951 { 1952 String lhsId; 1953 lhsId = this.getId(); 1954 String rhsId; 1955 rhsId = that.getId(); 1956 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 1957 return false; 1958 } 1959 } 1960 return true; 1961 } 1962 1963 public boolean equals(Object object) { 1964 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1965 return equals(null, null, object, strategy); 1966 } 1967 1968 1969 /** 1970 * <p>Java class for anonymous complex type. 1971 * 1972 * <p>The following schema fragment specifies the expected content contained within this class. 1973 * 1974 * <pre> 1975 * <complexType> 1976 * <complexContent> 1977 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1978 * <choice minOccurs="0"> 1979 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 1980 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 1981 * <any namespace='##other'/> 1982 * </choice> 1983 * </restriction> 1984 * </complexContent> 1985 * </complexType> 1986 * </pre> 1987 * 1988 * 1989 */ 1990 @XmlAccessorType(XmlAccessType.FIELD) 1991 @XmlType(name = "", propOrder = { 1992 "broker", 1993 "brokerService", 1994 "any" 1995 }) 1996 public static class BrokerService 1997 implements Equals, HashCode, ToString 1998 { 1999 2000 protected DtoBroker broker; 2001 protected DtoBrokerService brokerService; 2002 @XmlAnyElement(lax = true) 2003 protected Object any; 2004 2005 /** 2006 * Gets the value of the broker property. 2007 * 2008 * @return 2009 * possible object is 2010 * {@link DtoBroker } 2011 * 2012 */ 2013 public DtoBroker getBroker() { 2014 return broker; 2015 } 2016 2017 /** 2018 * Sets the value of the broker property. 2019 * 2020 * @param value 2021 * allowed object is 2022 * {@link DtoBroker } 2023 * 2024 */ 2025 public void setBroker(DtoBroker value) { 2026 this.broker = value; 2027 } 2028 2029 /** 2030 * Gets the value of the brokerService property. 2031 * 2032 * @return 2033 * possible object is 2034 * {@link DtoBrokerService } 2035 * 2036 */ 2037 public DtoBrokerService getBrokerService() { 2038 return brokerService; 2039 } 2040 2041 /** 2042 * Sets the value of the brokerService property. 2043 * 2044 * @param value 2045 * allowed object is 2046 * {@link DtoBrokerService } 2047 * 2048 */ 2049 public void setBrokerService(DtoBrokerService value) { 2050 this.brokerService = value; 2051 } 2052 2053 /** 2054 * Gets the value of the any property. 2055 * 2056 * @return 2057 * possible object is 2058 * {@link Object } 2059 * 2060 */ 2061 public Object getAny() { 2062 return any; 2063 } 2064 2065 /** 2066 * Sets the value of the any property. 2067 * 2068 * @param value 2069 * allowed object is 2070 * {@link Object } 2071 * 2072 */ 2073 public void setAny(Object value) { 2074 this.any = value; 2075 } 2076 2077 public String toString() { 2078 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2079 final StringBuilder buffer = new StringBuilder(); 2080 append(null, buffer, strategy); 2081 return buffer.toString(); 2082 } 2083 2084 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2085 strategy.appendStart(locator, this, buffer); 2086 appendFields(locator, buffer, strategy); 2087 strategy.appendEnd(locator, this, buffer); 2088 return buffer; 2089 } 2090 2091 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2092 { 2093 DtoBroker theBroker; 2094 theBroker = this.getBroker(); 2095 strategy.appendField(locator, this, "broker", buffer, theBroker); 2096 } 2097 { 2098 DtoBrokerService theBrokerService; 2099 theBrokerService = this.getBrokerService(); 2100 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 2101 } 2102 { 2103 Object theAny; 2104 theAny = this.getAny(); 2105 strategy.appendField(locator, this, "any", buffer, theAny); 2106 } 2107 return buffer; 2108 } 2109 2110 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2111 int currentHashCode = 1; 2112 { 2113 DtoBroker theBroker; 2114 theBroker = this.getBroker(); 2115 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "broker", theBroker), currentHashCode, theBroker); 2116 } 2117 { 2118 DtoBrokerService theBrokerService; 2119 theBrokerService = this.getBrokerService(); 2120 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 2121 } 2122 { 2123 Object theAny; 2124 theAny = this.getAny(); 2125 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2126 } 2127 return currentHashCode; 2128 } 2129 2130 public int hashCode() { 2131 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2132 return this.hashCode(null, strategy); 2133 } 2134 2135 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2136 if (!(object instanceof DtoKahaDB.BrokerService)) { 2137 return false; 2138 } 2139 if (this == object) { 2140 return true; 2141 } 2142 final DtoKahaDB.BrokerService that = ((DtoKahaDB.BrokerService) object); 2143 { 2144 DtoBroker lhsBroker; 2145 lhsBroker = this.getBroker(); 2146 DtoBroker rhsBroker; 2147 rhsBroker = that.getBroker(); 2148 if (!strategy.equals(LocatorUtils.property(thisLocator, "broker", lhsBroker), LocatorUtils.property(thatLocator, "broker", rhsBroker), lhsBroker, rhsBroker)) { 2149 return false; 2150 } 2151 } 2152 { 2153 DtoBrokerService lhsBrokerService; 2154 lhsBrokerService = this.getBrokerService(); 2155 DtoBrokerService rhsBrokerService; 2156 rhsBrokerService = that.getBrokerService(); 2157 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 2158 return false; 2159 } 2160 } 2161 { 2162 Object lhsAny; 2163 lhsAny = this.getAny(); 2164 Object rhsAny; 2165 rhsAny = that.getAny(); 2166 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2167 return false; 2168 } 2169 } 2170 return true; 2171 } 2172 2173 public boolean equals(Object object) { 2174 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2175 return equals(null, null, object, strategy); 2176 } 2177 2178 } 2179 2180 2181 /** 2182 * <p>Java class for anonymous complex type. 2183 * 2184 * <p>The following schema fragment specifies the expected content contained within this class. 2185 * 2186 * <pre> 2187 * <complexType> 2188 * <complexContent> 2189 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2190 * <choice minOccurs="0"> 2191 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 2192 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 2193 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 2194 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 2195 * <any namespace='##other'/> 2196 * </choice> 2197 * </restriction> 2198 * </complexContent> 2199 * </complexType> 2200 * </pre> 2201 * 2202 * 2203 */ 2204 @XmlAccessorType(XmlAccessType.FIELD) 2205 @XmlType(name = "", propOrder = { 2206 "databaseLocker", 2207 "leaseDatabaseLocker", 2208 "sharedFileLocker", 2209 "transactDatabaseLocker", 2210 "any" 2211 }) 2212 public static class Locker 2213 implements Equals, HashCode, ToString 2214 { 2215 2216 @XmlElement(name = "database-locker") 2217 protected DtoDatabaseLocker databaseLocker; 2218 @XmlElement(name = "lease-database-locker") 2219 protected DtoLeaseDatabaseLocker leaseDatabaseLocker; 2220 @XmlElement(name = "shared-file-locker") 2221 protected DtoSharedFileLocker sharedFileLocker; 2222 @XmlElement(name = "transact-database-locker") 2223 protected DtoTransactDatabaseLocker transactDatabaseLocker; 2224 @XmlAnyElement(lax = true) 2225 protected Object any; 2226 2227 /** 2228 * Gets the value of the databaseLocker property. 2229 * 2230 * @return 2231 * possible object is 2232 * {@link DtoDatabaseLocker } 2233 * 2234 */ 2235 public DtoDatabaseLocker getDatabaseLocker() { 2236 return databaseLocker; 2237 } 2238 2239 /** 2240 * Sets the value of the databaseLocker property. 2241 * 2242 * @param value 2243 * allowed object is 2244 * {@link DtoDatabaseLocker } 2245 * 2246 */ 2247 public void setDatabaseLocker(DtoDatabaseLocker value) { 2248 this.databaseLocker = value; 2249 } 2250 2251 /** 2252 * Gets the value of the leaseDatabaseLocker property. 2253 * 2254 * @return 2255 * possible object is 2256 * {@link DtoLeaseDatabaseLocker } 2257 * 2258 */ 2259 public DtoLeaseDatabaseLocker getLeaseDatabaseLocker() { 2260 return leaseDatabaseLocker; 2261 } 2262 2263 /** 2264 * Sets the value of the leaseDatabaseLocker property. 2265 * 2266 * @param value 2267 * allowed object is 2268 * {@link DtoLeaseDatabaseLocker } 2269 * 2270 */ 2271 public void setLeaseDatabaseLocker(DtoLeaseDatabaseLocker value) { 2272 this.leaseDatabaseLocker = value; 2273 } 2274 2275 /** 2276 * Gets the value of the sharedFileLocker property. 2277 * 2278 * @return 2279 * possible object is 2280 * {@link DtoSharedFileLocker } 2281 * 2282 */ 2283 public DtoSharedFileLocker getSharedFileLocker() { 2284 return sharedFileLocker; 2285 } 2286 2287 /** 2288 * Sets the value of the sharedFileLocker property. 2289 * 2290 * @param value 2291 * allowed object is 2292 * {@link DtoSharedFileLocker } 2293 * 2294 */ 2295 public void setSharedFileLocker(DtoSharedFileLocker value) { 2296 this.sharedFileLocker = value; 2297 } 2298 2299 /** 2300 * Gets the value of the transactDatabaseLocker property. 2301 * 2302 * @return 2303 * possible object is 2304 * {@link DtoTransactDatabaseLocker } 2305 * 2306 */ 2307 public DtoTransactDatabaseLocker getTransactDatabaseLocker() { 2308 return transactDatabaseLocker; 2309 } 2310 2311 /** 2312 * Sets the value of the transactDatabaseLocker property. 2313 * 2314 * @param value 2315 * allowed object is 2316 * {@link DtoTransactDatabaseLocker } 2317 * 2318 */ 2319 public void setTransactDatabaseLocker(DtoTransactDatabaseLocker value) { 2320 this.transactDatabaseLocker = value; 2321 } 2322 2323 /** 2324 * Gets the value of the any property. 2325 * 2326 * @return 2327 * possible object is 2328 * {@link Object } 2329 * 2330 */ 2331 public Object getAny() { 2332 return any; 2333 } 2334 2335 /** 2336 * Sets the value of the any property. 2337 * 2338 * @param value 2339 * allowed object is 2340 * {@link Object } 2341 * 2342 */ 2343 public void setAny(Object value) { 2344 this.any = value; 2345 } 2346 2347 public String toString() { 2348 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2349 final StringBuilder buffer = new StringBuilder(); 2350 append(null, buffer, strategy); 2351 return buffer.toString(); 2352 } 2353 2354 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2355 strategy.appendStart(locator, this, buffer); 2356 appendFields(locator, buffer, strategy); 2357 strategy.appendEnd(locator, this, buffer); 2358 return buffer; 2359 } 2360 2361 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2362 { 2363 DtoDatabaseLocker theDatabaseLocker; 2364 theDatabaseLocker = this.getDatabaseLocker(); 2365 strategy.appendField(locator, this, "databaseLocker", buffer, theDatabaseLocker); 2366 } 2367 { 2368 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 2369 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 2370 strategy.appendField(locator, this, "leaseDatabaseLocker", buffer, theLeaseDatabaseLocker); 2371 } 2372 { 2373 DtoSharedFileLocker theSharedFileLocker; 2374 theSharedFileLocker = this.getSharedFileLocker(); 2375 strategy.appendField(locator, this, "sharedFileLocker", buffer, theSharedFileLocker); 2376 } 2377 { 2378 DtoTransactDatabaseLocker theTransactDatabaseLocker; 2379 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 2380 strategy.appendField(locator, this, "transactDatabaseLocker", buffer, theTransactDatabaseLocker); 2381 } 2382 { 2383 Object theAny; 2384 theAny = this.getAny(); 2385 strategy.appendField(locator, this, "any", buffer, theAny); 2386 } 2387 return buffer; 2388 } 2389 2390 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2391 int currentHashCode = 1; 2392 { 2393 DtoDatabaseLocker theDatabaseLocker; 2394 theDatabaseLocker = this.getDatabaseLocker(); 2395 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "databaseLocker", theDatabaseLocker), currentHashCode, theDatabaseLocker); 2396 } 2397 { 2398 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 2399 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 2400 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "leaseDatabaseLocker", theLeaseDatabaseLocker), currentHashCode, theLeaseDatabaseLocker); 2401 } 2402 { 2403 DtoSharedFileLocker theSharedFileLocker; 2404 theSharedFileLocker = this.getSharedFileLocker(); 2405 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "sharedFileLocker", theSharedFileLocker), currentHashCode, theSharedFileLocker); 2406 } 2407 { 2408 DtoTransactDatabaseLocker theTransactDatabaseLocker; 2409 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 2410 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactDatabaseLocker", theTransactDatabaseLocker), currentHashCode, theTransactDatabaseLocker); 2411 } 2412 { 2413 Object theAny; 2414 theAny = this.getAny(); 2415 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2416 } 2417 return currentHashCode; 2418 } 2419 2420 public int hashCode() { 2421 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2422 return this.hashCode(null, strategy); 2423 } 2424 2425 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2426 if (!(object instanceof DtoKahaDB.Locker)) { 2427 return false; 2428 } 2429 if (this == object) { 2430 return true; 2431 } 2432 final DtoKahaDB.Locker that = ((DtoKahaDB.Locker) object); 2433 { 2434 DtoDatabaseLocker lhsDatabaseLocker; 2435 lhsDatabaseLocker = this.getDatabaseLocker(); 2436 DtoDatabaseLocker rhsDatabaseLocker; 2437 rhsDatabaseLocker = that.getDatabaseLocker(); 2438 if (!strategy.equals(LocatorUtils.property(thisLocator, "databaseLocker", lhsDatabaseLocker), LocatorUtils.property(thatLocator, "databaseLocker", rhsDatabaseLocker), lhsDatabaseLocker, rhsDatabaseLocker)) { 2439 return false; 2440 } 2441 } 2442 { 2443 DtoLeaseDatabaseLocker lhsLeaseDatabaseLocker; 2444 lhsLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 2445 DtoLeaseDatabaseLocker rhsLeaseDatabaseLocker; 2446 rhsLeaseDatabaseLocker = that.getLeaseDatabaseLocker(); 2447 if (!strategy.equals(LocatorUtils.property(thisLocator, "leaseDatabaseLocker", lhsLeaseDatabaseLocker), LocatorUtils.property(thatLocator, "leaseDatabaseLocker", rhsLeaseDatabaseLocker), lhsLeaseDatabaseLocker, rhsLeaseDatabaseLocker)) { 2448 return false; 2449 } 2450 } 2451 { 2452 DtoSharedFileLocker lhsSharedFileLocker; 2453 lhsSharedFileLocker = this.getSharedFileLocker(); 2454 DtoSharedFileLocker rhsSharedFileLocker; 2455 rhsSharedFileLocker = that.getSharedFileLocker(); 2456 if (!strategy.equals(LocatorUtils.property(thisLocator, "sharedFileLocker", lhsSharedFileLocker), LocatorUtils.property(thatLocator, "sharedFileLocker", rhsSharedFileLocker), lhsSharedFileLocker, rhsSharedFileLocker)) { 2457 return false; 2458 } 2459 } 2460 { 2461 DtoTransactDatabaseLocker lhsTransactDatabaseLocker; 2462 lhsTransactDatabaseLocker = this.getTransactDatabaseLocker(); 2463 DtoTransactDatabaseLocker rhsTransactDatabaseLocker; 2464 rhsTransactDatabaseLocker = that.getTransactDatabaseLocker(); 2465 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactDatabaseLocker", lhsTransactDatabaseLocker), LocatorUtils.property(thatLocator, "transactDatabaseLocker", rhsTransactDatabaseLocker), lhsTransactDatabaseLocker, rhsTransactDatabaseLocker)) { 2466 return false; 2467 } 2468 } 2469 { 2470 Object lhsAny; 2471 lhsAny = this.getAny(); 2472 Object rhsAny; 2473 rhsAny = that.getAny(); 2474 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2475 return false; 2476 } 2477 } 2478 return true; 2479 } 2480 2481 public boolean equals(Object object) { 2482 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2483 return equals(null, null, object, strategy); 2484 } 2485 2486 } 2487 2488 2489 /** 2490 * <p>Java class for anonymous complex type. 2491 * 2492 * <p>The following schema fragment specifies the expected content contained within this class. 2493 * 2494 * <pre> 2495 * <complexType> 2496 * <complexContent> 2497 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2498 * <sequence minOccurs="0"> 2499 * <any maxOccurs="unbounded" minOccurs="0"/> 2500 * </sequence> 2501 * </restriction> 2502 * </complexContent> 2503 * </complexType> 2504 * </pre> 2505 * 2506 * 2507 */ 2508 @XmlAccessorType(XmlAccessType.FIELD) 2509 @XmlType(name = "", propOrder = { 2510 "any" 2511 }) 2512 public static class ScheduledThreadPoolExecutor 2513 implements Equals, HashCode, ToString 2514 { 2515 2516 @XmlAnyElement(lax = true) 2517 protected List<Object> any; 2518 2519 /** 2520 * Gets the value of the any property. 2521 * 2522 * <p> 2523 * This accessor method returns a reference to the live list, 2524 * not a snapshot. Therefore any modification you make to the 2525 * returned list will be present inside the JAXB object. 2526 * This is why there is not a <CODE>set</CODE> method for the any property. 2527 * 2528 * <p> 2529 * For example, to add a new item, do as follows: 2530 * <pre> 2531 * getAny().add(newItem); 2532 * </pre> 2533 * 2534 * 2535 * <p> 2536 * Objects of the following type(s) are allowed in the list 2537 * {@link Object } 2538 * 2539 * 2540 */ 2541 public List<Object> getAny() { 2542 if (any == null) { 2543 any = new ArrayList<Object>(); 2544 } 2545 return this.any; 2546 } 2547 2548 public String toString() { 2549 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2550 final StringBuilder buffer = new StringBuilder(); 2551 append(null, buffer, strategy); 2552 return buffer.toString(); 2553 } 2554 2555 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2556 strategy.appendStart(locator, this, buffer); 2557 appendFields(locator, buffer, strategy); 2558 strategy.appendEnd(locator, this, buffer); 2559 return buffer; 2560 } 2561 2562 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2563 { 2564 List<Object> theAny; 2565 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2566 strategy.appendField(locator, this, "any", buffer, theAny); 2567 } 2568 return buffer; 2569 } 2570 2571 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2572 int currentHashCode = 1; 2573 { 2574 List<Object> theAny; 2575 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2576 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2577 } 2578 return currentHashCode; 2579 } 2580 2581 public int hashCode() { 2582 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2583 return this.hashCode(null, strategy); 2584 } 2585 2586 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2587 if (!(object instanceof DtoKahaDB.ScheduledThreadPoolExecutor)) { 2588 return false; 2589 } 2590 if (this == object) { 2591 return true; 2592 } 2593 final DtoKahaDB.ScheduledThreadPoolExecutor that = ((DtoKahaDB.ScheduledThreadPoolExecutor) object); 2594 { 2595 List<Object> lhsAny; 2596 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2597 List<Object> rhsAny; 2598 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 2599 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2600 return false; 2601 } 2602 } 2603 return true; 2604 } 2605 2606 public boolean equals(Object object) { 2607 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2608 return equals(null, null, object, strategy); 2609 } 2610 2611 } 2612 2613 2614 /** 2615 * <p>Java class for anonymous complex type. 2616 * 2617 * <p>The following schema fragment specifies the expected content contained within this class. 2618 * 2619 * <pre> 2620 * <complexType> 2621 * <complexContent> 2622 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2623 * <sequence minOccurs="0"> 2624 * <any maxOccurs="unbounded" minOccurs="0"/> 2625 * </sequence> 2626 * </restriction> 2627 * </complexContent> 2628 * </complexType> 2629 * </pre> 2630 * 2631 * 2632 */ 2633 @XmlAccessorType(XmlAccessType.FIELD) 2634 @XmlType(name = "", propOrder = { 2635 "any" 2636 }) 2637 public static class TransactionIdTransformer 2638 implements Equals, HashCode, ToString 2639 { 2640 2641 @XmlAnyElement(lax = true) 2642 protected List<Object> any; 2643 2644 /** 2645 * Gets the value of the any property. 2646 * 2647 * <p> 2648 * This accessor method returns a reference to the live list, 2649 * not a snapshot. Therefore any modification you make to the 2650 * returned list will be present inside the JAXB object. 2651 * This is why there is not a <CODE>set</CODE> method for the any property. 2652 * 2653 * <p> 2654 * For example, to add a new item, do as follows: 2655 * <pre> 2656 * getAny().add(newItem); 2657 * </pre> 2658 * 2659 * 2660 * <p> 2661 * Objects of the following type(s) are allowed in the list 2662 * {@link Object } 2663 * 2664 * 2665 */ 2666 public List<Object> getAny() { 2667 if (any == null) { 2668 any = new ArrayList<Object>(); 2669 } 2670 return this.any; 2671 } 2672 2673 public String toString() { 2674 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2675 final StringBuilder buffer = new StringBuilder(); 2676 append(null, buffer, strategy); 2677 return buffer.toString(); 2678 } 2679 2680 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2681 strategy.appendStart(locator, this, buffer); 2682 appendFields(locator, buffer, strategy); 2683 strategy.appendEnd(locator, this, buffer); 2684 return buffer; 2685 } 2686 2687 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2688 { 2689 List<Object> theAny; 2690 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2691 strategy.appendField(locator, this, "any", buffer, theAny); 2692 } 2693 return buffer; 2694 } 2695 2696 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2697 int currentHashCode = 1; 2698 { 2699 List<Object> theAny; 2700 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2701 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2702 } 2703 return currentHashCode; 2704 } 2705 2706 public int hashCode() { 2707 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2708 return this.hashCode(null, strategy); 2709 } 2710 2711 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2712 if (!(object instanceof DtoKahaDB.TransactionIdTransformer)) { 2713 return false; 2714 } 2715 if (this == object) { 2716 return true; 2717 } 2718 final DtoKahaDB.TransactionIdTransformer that = ((DtoKahaDB.TransactionIdTransformer) object); 2719 { 2720 List<Object> lhsAny; 2721 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 2722 List<Object> rhsAny; 2723 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 2724 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2725 return false; 2726 } 2727 } 2728 return true; 2729 } 2730 2731 public boolean equals(Object object) { 2732 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2733 return equals(null, null, object, strategy); 2734 } 2735 2736 } 2737 2738 2739 /** 2740 * <p>Java class for anonymous complex type. 2741 * 2742 * <p>The following schema fragment specifies the expected content contained within this class. 2743 * 2744 * <pre> 2745 * <complexType> 2746 * <complexContent> 2747 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2748 * <choice minOccurs="0"> 2749 * <element ref="{http://activemq.apache.org/schema/core}systemUsage"/> 2750 * <any namespace='##other'/> 2751 * </choice> 2752 * </restriction> 2753 * </complexContent> 2754 * </complexType> 2755 * </pre> 2756 * 2757 * 2758 */ 2759 @XmlAccessorType(XmlAccessType.FIELD) 2760 @XmlType(name = "", propOrder = { 2761 "systemUsage", 2762 "any" 2763 }) 2764 public static class UsageManager 2765 implements Equals, HashCode, ToString 2766 { 2767 2768 protected DtoSystemUsage systemUsage; 2769 @XmlAnyElement(lax = true) 2770 protected Object any; 2771 2772 /** 2773 * Gets the value of the systemUsage property. 2774 * 2775 * @return 2776 * possible object is 2777 * {@link DtoSystemUsage } 2778 * 2779 */ 2780 public DtoSystemUsage getSystemUsage() { 2781 return systemUsage; 2782 } 2783 2784 /** 2785 * Sets the value of the systemUsage property. 2786 * 2787 * @param value 2788 * allowed object is 2789 * {@link DtoSystemUsage } 2790 * 2791 */ 2792 public void setSystemUsage(DtoSystemUsage value) { 2793 this.systemUsage = value; 2794 } 2795 2796 /** 2797 * Gets the value of the any property. 2798 * 2799 * @return 2800 * possible object is 2801 * {@link Object } 2802 * 2803 */ 2804 public Object getAny() { 2805 return any; 2806 } 2807 2808 /** 2809 * Sets the value of the any property. 2810 * 2811 * @param value 2812 * allowed object is 2813 * {@link Object } 2814 * 2815 */ 2816 public void setAny(Object value) { 2817 this.any = value; 2818 } 2819 2820 public String toString() { 2821 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2822 final StringBuilder buffer = new StringBuilder(); 2823 append(null, buffer, strategy); 2824 return buffer.toString(); 2825 } 2826 2827 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2828 strategy.appendStart(locator, this, buffer); 2829 appendFields(locator, buffer, strategy); 2830 strategy.appendEnd(locator, this, buffer); 2831 return buffer; 2832 } 2833 2834 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2835 { 2836 DtoSystemUsage theSystemUsage; 2837 theSystemUsage = this.getSystemUsage(); 2838 strategy.appendField(locator, this, "systemUsage", buffer, theSystemUsage); 2839 } 2840 { 2841 Object theAny; 2842 theAny = this.getAny(); 2843 strategy.appendField(locator, this, "any", buffer, theAny); 2844 } 2845 return buffer; 2846 } 2847 2848 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2849 int currentHashCode = 1; 2850 { 2851 DtoSystemUsage theSystemUsage; 2852 theSystemUsage = this.getSystemUsage(); 2853 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "systemUsage", theSystemUsage), currentHashCode, theSystemUsage); 2854 } 2855 { 2856 Object theAny; 2857 theAny = this.getAny(); 2858 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2859 } 2860 return currentHashCode; 2861 } 2862 2863 public int hashCode() { 2864 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2865 return this.hashCode(null, strategy); 2866 } 2867 2868 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2869 if (!(object instanceof DtoKahaDB.UsageManager)) { 2870 return false; 2871 } 2872 if (this == object) { 2873 return true; 2874 } 2875 final DtoKahaDB.UsageManager that = ((DtoKahaDB.UsageManager) object); 2876 { 2877 DtoSystemUsage lhsSystemUsage; 2878 lhsSystemUsage = this.getSystemUsage(); 2879 DtoSystemUsage rhsSystemUsage; 2880 rhsSystemUsage = that.getSystemUsage(); 2881 if (!strategy.equals(LocatorUtils.property(thisLocator, "systemUsage", lhsSystemUsage), LocatorUtils.property(thatLocator, "systemUsage", rhsSystemUsage), lhsSystemUsage, rhsSystemUsage)) { 2882 return false; 2883 } 2884 } 2885 { 2886 Object lhsAny; 2887 lhsAny = this.getAny(); 2888 Object rhsAny; 2889 rhsAny = that.getAny(); 2890 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2891 return false; 2892 } 2893 } 2894 return true; 2895 } 2896 2897 public boolean equals(Object object) { 2898 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2899 return equals(null, null, object, strategy); 2900 } 2901 2902 } 2903 2904}