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