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