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