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