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