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